relations_negative.rs

use crate::{common::*, with_header, Provider};

#[test]
fn fail_if_ambiguous_relation_fields_do_not_specify_a_name() {
    let dml = indoc! {r#"
        model Todo {
          id Int @id
          comments Comment[]
          comments2 Comment[]
        }

        model Comment {
          id Int @id
          text String
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "Todo": Ambiguous relation detected. The fields `comments` and `comments2` in model `Todo` both refer to `Comment`. Please provide different relation names for them by adding `@relation(<name>).
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   comments Comment[]
         4 |   comments2 Comment[]
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn fail_if_naming_relation_fields_the_same_as_the_explicit_names() {
    let dml = indoc! {r#"
        model Club {
          id                 Int      @id @default(autoincrement())
          adminId            Int      @map("admin_id")
          admin              User     @relation(fields: [adminId], references: [id])
          members            User[]   @relation("ClubToUser")

          @@map("clubs")
        }

        model User {
          id                 Int       @id @default(autoincrement())
          clubs_clubsTousers Club[]    @relation("ClubToUser")
          ownedClubs         Club[]

          @@map("users")
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "Club": Ambiguous relation detected. The fields `admin` and `members` in model `Club` both refer to `User`. Please provide different relation names for them by adding `@relation(<name>).
          -->  schema.prisma:4
           | 
         3 |   adminId            Int      @map("admin_id")
         4 |   admin              User     @relation(fields: [adminId], references: [id])
         5 |   members            User[]   @relation("ClubToUser")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn must_error_when_non_existing_fields_are_used() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          firstName String
          lastName String
          posts Post[]

          @@unique([firstName, lastName])
        }

        model Post {
          id   Int    @id
          text String
          user User   @relation(fields: [authorFirstName, authorLastName], references: [firstName, lastName])
        }
    "#};

    let expect = expect![[r#"
        error: Error validating: The argument fields must refer only to existing fields. The following fields do not exist in this model: authorFirstName, authorLastName
          -->  schema.prisma:13
           | 
        12 |   text String
        13 |   user User   @relation(fields: [authorFirstName, authorLastName], references: [firstName, lastName])
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_ambiguous_relations_with_automatic_names_1() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          posts Post[]
          more_posts Post[]
        }

        model Post {
          post_id Int @id
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "User": Ambiguous relation detected. The fields `posts` and `more_posts` in model `User` both refer to `Post`. Please provide different relation names for them by adding `@relation(<name>).
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   posts Post[]
         4 |   more_posts Post[]
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_colliding_implicit_self_relations() {
    let dml = indoc! {r#"
        model User {
          id          Int      @id @default(autoincrement())
          name        String?

          husband     User?    @relation("MarriagePartners")
          wife        User     @relation("MarriagePartners")

          teacher     User?    @relation("TeacherStudents")
          students    User[]   @relation("TeacherStudents")
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": The relation fields `wife` on Model `User` and `husband` on Model `User` do not provide the `fields` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:6
           | 
         5 |   husband     User?    @relation("MarriagePartners")
         6 |   wife        User     @relation("MarriagePartners")
         7 | 
           | 
        error: Error parsing attribute "@relation": The relation fields `husband` on Model `User` and `wife` on Model `User` do not provide the `fields` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:5
           | 
         4 | 
         5 |   husband     User?    @relation("MarriagePartners")
         6 |   wife        User     @relation("MarriagePartners")
           | 
        error: Error parsing attribute "@relation": The relation fields `wife` on Model `User` and `husband` on Model `User` do not provide the `references` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:6
           | 
         5 |   husband     User?    @relation("MarriagePartners")
         6 |   wife        User     @relation("MarriagePartners")
         7 | 
           | 
        error: Error parsing attribute "@relation": The relation fields `husband` on Model `User` and `wife` on Model `User` do not provide the `references` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:5
           | 
         4 | 
         5 |   husband     User?    @relation("MarriagePartners")
         6 |   wife        User     @relation("MarriagePartners")
           | 
        error: Error parsing attribute "@relation": The relation field `teacher` on Model `User` must specify the `fields` argument in the @relation attribute. You can run `prisma format` to fix this automatically.
          -->  schema.prisma:8
           | 
         7 | 
         8 |   teacher     User?    @relation("TeacherStudents")
         9 |   students    User[]   @relation("TeacherStudents")
           | 
        error: Error parsing attribute "@relation": The relation field `teacher` on Model `User` must specify the `references` argument in the @relation attribute.
          -->  schema.prisma:8
           | 
         7 | 
         8 |   teacher     User?    @relation("TeacherStudents")
         9 |   students    User[]   @relation("TeacherStudents")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_ambiguous_relations_with_automatic_names_2() {
    // test case based on: https://github.com/prisma/prisma2/issues/976
    let dml = indoc! {r#"
        model User {
          id Int @id
          posts Post[]
        }

        model Post {
          post_id Int @id
          author1 User
          author2 User
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "Post": Ambiguous relation detected. The fields `author1` and `author2` in model `Post` both refer to `User`. Please provide different relation names for them by adding `@relation(<name>).
          -->  schema.prisma:8
           | 
         7 |   post_id Int @id
         8 |   author1 User
         9 |   author2 User
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_ambiguous_relations_with_manual_names_1() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          posts Post[] @relation(name: "test")
          more_posts Post[] @relation(name: "test")
        }

        model Post {
          post_id Int @id
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "User": Wrongly named relation detected. The fields `posts` and `more_posts` in model `User` both use the same relation name. Please provide different relation names for them through `@relation(<name>).
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   posts Post[] @relation(name: "test")
         4 |   more_posts Post[] @relation(name: "test")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_ambiguous_relations_with_manual_names_2() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          posts Post[] @relation(name: "a")
          more_posts Post[] @relation(name: "b")
          some_posts Post[]
          even_more_posts Post[] @relation(name: "a")
        }

        model Post {
          post_id Int @id
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "User": Wrongly named relation detected. The fields `posts` and `even_more_posts` in model `User` both use the same relation name. Please provide different relation names for them through `@relation(<name>).
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   posts Post[] @relation(name: "a")
         4 |   more_posts Post[] @relation(name: "b")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_ambiguous_self_relation() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          father User
          son User
          mother User
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "User": Unnamed self relation detected. The fields `father`, `son` and `mother` in model `User` have no relation name. Please provide a relation name for one of them by adding `@relation(<name>).
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   father User
         4 |   son User
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_ambiguous_self_relation_with_two_fields() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          child User
          mother User
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "User": Ambiguous self relation detected. The fields `child` and `mother` in model `User` both refer to `User`. If they are part of the same relation add the same relation name for them with `@relation(<name>)`.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   child User
         4 |   mother User
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_ambiguous_named_self_relation() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          father User @relation(name: "family")
          son User @relation(name: "family")
          mother User @relation(name: "family")
        }
    "#};

    let expect = expect![[r#"
        error: Error validating model "User": Wrongly named self relation detected. The fields `father`, `son` and `mother` in model `User` have the same relation name. At most two relation fields can belong to the same relation and therefore have the same name. Please assign a different relation name to one of them.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   father User @relation(name: "family")
         4 |   son User @relation(name: "family")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_conflicting_back_relation_field_name() {
    let dml = indoc! {r#"
        model User {
          id Int @id
          posts Post[] @relation(name: "test")
          more_posts Post[]
        }

        model Post {
          post_id Int @id
          User User @relation(name: "test")
        }
    "#};

    let expect = expect![[r#"
        error: Error validating field `more_posts` in model `User`: The relation field `more_posts` on Model `User` is missing an opposite relation field on the model `Post`. Either run `prisma format` or add it manually.
          -->  schema.prisma:4
           | 
         3 |   posts Post[] @relation(name: "test")
         4 |   more_posts Post[]
         5 | }
           | 
        error: Error parsing attribute "@relation": The relation field `User` on Model `Post` must specify the `fields` argument in the @relation attribute. You can run `prisma format` to fix this automatically.
          -->  schema.prisma:9
           | 
         8 |   post_id Int @id
         9 |   User User @relation(name: "test")
        10 | }
           | 
        error: Error parsing attribute "@relation": The relation field `User` on Model `Post` must specify the `references` argument in the @relation attribute.
          -->  schema.prisma:9
           | 
         8 |   post_id Int @id
         9 |   User User @relation(name: "test")
        10 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]

//todo formatter should make an offer
fn should_fail_when_relation_attribute_is_missing_for_one_to_one_relations() {
    // Post is lower that User. So the references should be stored in Post.
    let dml = indoc! {r#"
        model User {
          user_id Int  @id
          post    Post
        }

        model Post {
          post_id Int  @id
          user    User
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": The relation fields `user` on Model `Post` and `post` on Model `User` do not provide the `fields` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:8
           | 
         7 |   post_id Int  @id
         8 |   user    User
         9 | }
           | 
        error: Error parsing attribute "@relation": The relation fields `post` on Model `User` and `user` on Model `Post` do not provide the `fields` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:3
           | 
         2 |   user_id Int  @id
         3 |   post    Post
         4 | }
           | 
        error: Error parsing attribute "@relation": The relation fields `user` on Model `Post` and `post` on Model `User` do not provide the `references` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:8
           | 
         7 |   post_id Int  @id
         8 |   user    User
         9 | }
           | 
        error: Error parsing attribute "@relation": The relation fields `post` on Model `User` and `user` on Model `Post` do not provide the `references` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:3
           | 
         2 |   user_id Int  @id
         3 |   post    Post
         4 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_conflicting_generated_back_relation_fields() {
    // More specifically, this should not panic.
    let dml = indoc! {r#"
        model Todo {
          id Int @id
          author Owner @relation(name: "AuthorTodo")
          delegatedTo Owner? @relation(name: "DelegatedToTodo")
        }

        model Owner {
          id Int @id
          todos Todo[]
        }
    "#};

    let expect = expect![[r#"
        error: Error validating field `author` in model `Todo`: The relation field `author` on Model `Todo` is missing an opposite relation field on the model `Owner`. Either run `prisma format` or add it manually.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   author Owner @relation(name: "AuthorTodo")
         4 |   delegatedTo Owner? @relation(name: "DelegatedToTodo")
           | 
        error: Error validating field `delegatedTo` in model `Todo`: The relation field `delegatedTo` on Model `Todo` is missing an opposite relation field on the model `Owner`. Either run `prisma format` or add it manually.
          -->  schema.prisma:4
           | 
         3 |   author Owner @relation(name: "AuthorTodo")
         4 |   delegatedTo Owner? @relation(name: "DelegatedToTodo")
         5 | }
           | 
        error: Error validating field `todos` in model `Owner`: The relation field `todos` on Model `Owner` is missing an opposite relation field on the model `Todo`. Either run `prisma format` or add it manually.
          -->  schema.prisma:9
           | 
         8 |   id Int @id
         9 |   todos Todo[]
        10 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

//reformat implicit relations test files

//todo this talked about adding backrelation fields but was adding forward field + scalarfield
#[test]
fn must_generate_forward_relation_fields_for_named_relation_fields() {
    //reject, hint to prisma format, add scalar field and relation field, validate again
    let dml = indoc! {r#"
        model Todo {
          id Int @id
          assignees User[] @relation(name: "AssignedTodos")
        }

        model User {
          id Int @id
        }
    "#};

    let expect = expect![[r#"
        error: Error validating field `assignees` in model `Todo`: The relation field `assignees` on Model `Todo` is missing an opposite relation field on the model `User`. Either run `prisma format` or add it manually.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   assignees User[] @relation(name: "AssignedTodos")
         4 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

// todo this is also accepted and adds a postId scalar field under the hood on PostableEntity
// is almost the exact same case as the one above (minus the relationname), but reported as a bug and also understood by harshit as such
#[test]
fn issue4850() {
    //reject, hint to prisma format, add scalar field and relation field, validate again
    let dml = indoc! {r#"
        model PostableEntity {
          id String @id
        }

        model Post {
          id String @id
          postableEntities PostableEntity[]
        }
    "#};

    let expect = expect![[r#"
        error: Error validating field `postableEntities` in model `Post`: The relation field `postableEntities` on Model `Post` is missing an opposite relation field on the model `PostableEntity`. Either run `prisma format` or add it manually.
          -->  schema.prisma:7
           | 
         6 |   id String @id
         7 |   postableEntities PostableEntity[]
         8 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

//todo I think this should be fine and just add the @relation and relationname to the backrelation field
// but this interprets the dm as containing two relations.
#[test]
fn issue4822() {
    //reject, ask to name custom_Post relation
    let dml = indoc! {r#"
        model Post {
          id          Int    @id
          user_id     Int    @unique
          custom_User User   @relation("CustomName", fields: [user_id], references: [id])
        }

        model User {
          id          Int    @id
          custom_Post Post?
        }
    "#};

    let expect = expect![[r#"
        error: Error validating field `custom_User` in model `Post`: The relation field `custom_User` on Model `Post` is missing an opposite relation field on the model `User`. Either run `prisma format` or add it manually.
          -->  schema.prisma:4
           | 
         3 |   user_id     Int    @unique
         4 |   custom_User User   @relation("CustomName", fields: [user_id], references: [id])
         5 | }
           | 
        error: Error validating field `custom_Post` in model `User`: The relation field `custom_Post` on Model `User` is missing an opposite relation field on the model `Post`. Either run `prisma format` or add it manually.
          -->  schema.prisma:9
           | 
         8 |   id          Int    @id
         9 |   custom_Post Post?
        10 | }
           | 
    "#]];

    expect_error(dml, &expect);
}

#[test]
fn issue5216() {
    let dml = indoc! {r#"
        model user {
          id             String        @id
          email          String        @unique
          organization   organization? @relation(references: [id])
        }

        model organization {
          id        String   @id
          users     user[]
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": The relation field `organization` on Model `user` must specify the `fields` argument in the @relation attribute. You can run `prisma format` to fix this automatically.
          -->  schema.prisma:4
           | 
         3 |   email          String        @unique
         4 |   organization   organization? @relation(references: [id])
         5 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

//todo this is also accepted but will under the hood point the createdBy relationfield to the same userId scalar
// as the user relationfield
// duplicate of 5540
// comment by matt:
// We don't want to remove the formatting feature that adds @relation and foreign key, this is a beloved feature.
// We want the validator to ensure that @relation always exists and links to a valid field.
// If the formatter is unable to correctly add @relation because of an ambiguity (e.g. user & createdBy), it shouldn't try. The validator will just tell you that you're missing @relation and need to add them in by hand to resolve the issue.
#[test]
fn issue5069() {
    // reject
    let dml = indoc! {r#"
        model Code {
          id          String        @id
          createdById String?
          createdBy   User?

          userId      String?
          user        User?         @relation("code", fields: [userId], references: [id])
        }

        model User {
          id         String         @id
          codes      Code[]         @relation("code")
        }
    "#};

    let expect = expect![[r#"
        error: Error validating field `createdBy` in model `Code`: The relation field `createdBy` on Model `Code` is missing an opposite relation field on the model `User`. Either run `prisma format` or add it manually.
          -->  schema.prisma:4
           | 
         3 |   createdById String?
         4 |   createdBy   User?
         5 | 
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn must_add_referenced_fields_on_both_sides_for_one_to_many_relations() {
    let dml = indoc! {r#"
        model User {
          user_id Int    @id
          posts   Post[]
        }

        model Post {
          post_id Int    @id
          user    User
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": The relation field `user` on Model `Post` must specify the `fields` argument in the @relation attribute. You can run `prisma format` to fix this automatically.
          -->  schema.prisma:8
           | 
         7 |   post_id Int    @id
         8 |   user    User
         9 | }
           | 
        error: Error parsing attribute "@relation": The relation field `user` on Model `Post` must specify the `references` argument in the @relation attribute.
          -->  schema.prisma:8
           | 
         7 |   post_id Int    @id
         8 |   user    User
         9 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));

    // prove that lexicographic order does not have an influence.
    let dml = indoc! {r#"
        model User {
          user_id Int    @id
          post    Post
        }

        model Post {
          post_id Int    @id
          users   User[]
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": The relation field `post` on Model `User` must specify the `fields` argument in the @relation attribute. You can run `prisma format` to fix this automatically.
          -->  schema.prisma:3
           | 
         2 |   user_id Int    @id
         3 |   post    Post
         4 | }
           | 
        error: Error parsing attribute "@relation": The relation field `post` on Model `User` must specify the `references` argument in the @relation attribute.
          -->  schema.prisma:3
           | 
         2 |   user_id Int    @id
         3 |   post    Post
         4 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_on_missing_embed_ids_on_self_relations() {
    let dml = indoc! {r#"
        model Human {
          id Int @id
          father Human? @relation("paternity")
          son Human? @relation("paternity")
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": The relation fields `father` on Model `Human` and `son` on Model `Human` do not provide the `fields` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   father Human? @relation("paternity")
         4 |   son Human? @relation("paternity")
           | 
        error: Error parsing attribute "@relation": The relation fields `son` on Model `Human` and `father` on Model `Human` do not provide the `fields` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:4
           | 
         3 |   father Human? @relation("paternity")
         4 |   son Human? @relation("paternity")
         5 | }
           | 
        error: Error parsing attribute "@relation": The relation fields `father` on Model `Human` and `son` on Model `Human` do not provide the `references` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:3
           | 
         2 |   id Int @id
         3 |   father Human? @relation("paternity")
         4 |   son Human? @relation("paternity")
           | 
        error: Error parsing attribute "@relation": The relation fields `son` on Model `Human` and `father` on Model `Human` do not provide the `references` argument in the @relation attribute. You have to provide it on one of the two fields.
          -->  schema.prisma:4
           | 
         3 |   father Human? @relation("paternity")
         4 |   son Human? @relation("paternity")
         5 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn mapping_foreign_keys_with_a_name_that_is_too_long_should_error() {
    let dml = with_header(
        indoc! {r#"
        model User {
          id Int    @id
          posts   Post[]
        }

        model Post {
          post_id Int    @id
          user_id Int
          user    User   @relation(fields:[post_id], references: [id], map: "IfYouAreGoingToPickTheNameYourselfYouShouldReallyPickSomethingShortAndSweetInsteadOfASuperLongNameViolatingLengthLimits")
        }
    "#},
        Provider::Postgres,
        &[],
    );

    let expect = expect![[r#"
        error: Error validating model "Post": The constraint name 'IfYouAreGoingToPickTheNameYourselfYouShouldReallyPickSomethingShortAndSweetInsteadOfASuperLongNameViolatingLengthLimits' specified in the `map` argument for the `@relation` constraint is too long for your chosen provider. The maximum allowed length is 63 bytes.
          -->  schema.prisma:19
           | 
        18 |   user_id Int
        19 |   user    User   @relation(fields:[post_id], references: [id], map: "IfYouAreGoingToPickTheNameYourselfYouShouldReallyPickSomethingShortAndSweetInsteadOfASuperLongNameViolatingLengthLimits")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(&dml));
}

#[test]
fn mapping_foreign_keys_on_sqlite_should_error() {
    let dml = indoc! {r#"
        datasource test {
          provider = "sqlite"
          url = "file:."
        }

        model User {
          id Int    @id
          posts   Post[]
        }

        model Post {
          post_id Int    @id
          user_id Int
          user    User   @relation(fields:[post_id], references: [id], map: "NoNamedForeignKeysOnSQLite")
        }
     "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": Your provider does not support named foreign keys.
          -->  schema.prisma:14
           | 
        13 |   user_id Int
        14 |   user    User   @relation(fields:[post_id], references: [id], map: "NoNamedForeignKeysOnSQLite")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn relation_field_in_composite_type_errors() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        type Address {
            street String
            test Test
        }

        model Test {
            id Int @id
        }
    "#;

    let expect = expect![[r#"
        error: Error validating composite type "Address": Test refers to a model, making this a relation field. Relation fields inside composite types are not supported.
          -->  schema.prisma:9
           | 
         8 |             street String
         9 |             test Test
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(schema));
}

#[test]
fn relation_attribute_on_a_composite_field_errors() {
    let schema = r#"
        datasource db {
            provider = "mongodb"
            url = "mongodb://"
        }

        type Address {
            street String
        }

        model Test {
            id Int @id
            addres Address? @relation("TestAddress")
        }
    "#;

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": Invalid field type, not a relation.
          -->  schema.prisma:13
           | 
        12 |             id Int @id
        13 |             addres Address? @relation("TestAddress")
           | 
        error: No such argument.
          -->  schema.prisma:13
           | 
        12 |             id Int @id
        13 |             addres Address? @relation("TestAddress")
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(schema));
}

#[test]
fn a_typoed_relation_should_fail_gracefully() {
    let dml = indoc! {r#"
        datasource db {
          provider = "sqlserver"
          url      = env("DATABASE_URL")
        }

        model Test {
          id         Int        @id
          fk         Int
          testparent TestParent @relation(fields: [fk], references: [id])
        }

        model TestParent {
          id    Int    @id
          tests Test[]

          fk   Int
          self TestParent @relation(fields: [fk], references: [id])
        }
    "#};

    let expect = expect![[r#"
        error: Error validating field `self` in model `TestParent`: The relation field `self` on Model `TestParent` is missing an opposite relation field on the model `TestParent`. Either run `prisma format` or add it manually.
          -->  schema.prisma:17
           | 
        16 |   fk   Int
        17 |   self TestParent @relation(fields: [fk], references: [id])
        18 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn cannot_use_references_with_many_to_many_relations() {
    let dml = indoc! {r#"
        model User {
          id      Int    @id
          post_id Int
          posts   Post[] @relation("a", references: [id])
        }

        model Post {
          id      Int    @id
          user_id Int
          users   User[] @relation("a", references: [id])
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": Implicit many-to-many relation should not have references argument defined. Either remove it, or change the relation to one-to-many.
          -->  schema.prisma:10
           | 
         9 |   user_id Int
        10 |   users   User[] @relation("a", references: [id])
        11 | }
           | 
        error: Error parsing attribute "@relation": Implicit many-to-many relation should not have references argument defined. Either remove it, or change the relation to one-to-many.
          -->  schema.prisma:4
           | 
         3 |   post_id Int
         4 |   posts   Post[] @relation("a", references: [id])
         5 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_if_not_using_unique_constraint_with_singular_one_to_one() {
    let dml = indoc! {r#"
        model A {
          id Int  @id
          fk Int?
          b  B?   @relation(fields: [fk], references: [id])
        }

        model B {
          id Int @id
          a  A?
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": A one-to-one relation must use unique fields on the defining side. Either add an `@unique` attribute to the field `fk`, or change the relation to one-to-many.
          -->  schema.prisma:4
           | 
         3 |   fk Int?
         4 |   b  B?   @relation(fields: [fk], references: [id])
         5 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_if_not_using_unique_constraint_with_compound_one_to_one() {
    let dml = indoc! {r#"
        model A {
          id Int  @id
          fk1 Int?
          fk2 Int?
          b   B?   @relation(fields: [fk1, fk2], references: [id1, id2])
        }

        model B {
          id1 Int
          id2 Int
          a   A?

          @@id([id1, id2])
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": A one-to-one relation must use unique fields on the defining side. Either add an `@@unique([fk1, fk2])` attribute to the model, or change the relation to one-to-many.
          -->  schema.prisma:5
           | 
         4 |   fk2 Int?
         5 |   b   B?   @relation(fields: [fk1, fk2], references: [id1, id2])
         6 | }
           | 
    "#]];

    expect.assert_eq(&parse_unwrap_err(dml));
}

#[test]
fn should_fail_if_not_using_unique_constraint_with_single_one_to_many() {
    let dml = indoc! {r#"
        model A {
          id         Int          @id @default(autoincrement())
          custom_id  String
          B          B[]

          @@index([custom_id])
        }

        model B {
          id        Int     @id @default(autoincrement())
          a_id String
          A         A @relation(fields: [a_id], references: [custom_id])
        }
    "#};

    let expect = expect![[r#"
        error: Error parsing attribute "@relation": The argument `references` must refer to a unique criterion in the related model. Consider adding an `@unique` attribute to the field `custom_id` in the model `A`.
          -->  schema.prisma:22
           | 
        21 |   a_id String
        22 |   A         A @relation(fields: [a_id], references: [custom_id])
        23 | }
           | 
    "#]];

    let dml = with_header(dml, Provider::Mysql, &[]);

    expect.assert_eq(&parse_unwrap_err(&dml));
}

#[test]
fn multiple_relation_validation_errors_do_not_prevent_each_other_across_models() {
    let schema = r#"
        generator client {
          provider      = "prisma-client-js"
          binaryTargets = ["darwin"]
        }

        datasource db {
          provider = "mysql"
          url      = env("DATABASE_URL")
        }

        model Post {
          POST_ID            Int  @id @db.UnsignedInt
          USER_NON_UNIQUE_ID Int  @db.UnsignedInt
          User               User @relation(fields: [USER_NON_UNIQUE_ID], references: [USER_NON_UNIQUE_ID], onUpdate: Restrict, map: "FK_USER_NON_UNIQUE_ID")

          @@index([USER_NON_UNIQUE_ID], map: "FK_USER_NON_UNIQUE_ID")
        }

        model User {
          USER_ID            Int    @id @default(autoincrement()) @db.UnsignedInt
          USER_NON_UNIQUE_ID Int    @db.UnsignedInt
          Post               Post[]

          @@index([USER_NON_UNIQUE_ID], map: "index_name")
        }

        model stock {
          STOCK_ID            Int           @id @default(autoincrement()) @db.UnsignedInt
          STOCK_NON_UNIQUE_ID Int           @db.UnsignedInt
          stock_detail        stock_detail?

          @@index([STOCK_NON_UNIQUE_ID], map: "index_name")
        }

        model stock_detail {
          STOCK_ID Int   @id @db.UnsignedInt
          stock    stock @relation(fields: [STOCK_ID], references: [STOCK_NON_UNIQUE_ID], onUpdate: Restrict, map: "FK_STOCK_NON_UNIQUE_ID")
        }
    "#;

    let expected_error = expect![[r#"
        error: Error parsing attribute "@relation": The argument `references` must refer to a unique criterion in the related model. Consider adding an `@unique` attribute to the field `USER_NON_UNIQUE_ID` in the model `User`.
          -->  schema.prisma:15
           | 
        14 |           USER_NON_UNIQUE_ID Int  @db.UnsignedInt
        15 |           User               User @relation(fields: [USER_NON_UNIQUE_ID], references: [USER_NON_UNIQUE_ID], onUpdate: Restrict, map: "FK_USER_NON_UNIQUE_ID")
        16 | 
           | 
        error: Error parsing attribute "@relation": The argument `references` must refer to a unique criterion in the related model. Consider adding an `@unique` attribute to the field `STOCK_NON_UNIQUE_ID` in the model `stock`.
          -->  schema.prisma:38
           | 
        37 |           STOCK_ID Int   @id @db.UnsignedInt
        38 |           stock    stock @relation(fields: [STOCK_ID], references: [STOCK_NON_UNIQUE_ID], onUpdate: Restrict, map: "FK_STOCK_NON_UNIQUE_ID")
        39 |         }
           | 
    "#]];

    expect_error(schema, &expected_error)
}