What you need here is connectOrCreate.

So something like this should work:

      await prisma.post.create({
        data: {
          title: 'Hello',
          categories: {
            create: [
              {
                category: {
                  create: {
                    name: 'category-1',
                  },
                },
              },
              { category: { connect: { id: 10 } } },
            ],
          },
        },
      });

You can also read more about this in the docs here

Hi @nicolas-goudry 👋

Thank you for raising this question.

Using an explicit many-to-many relation instead of an implicit one can make the Prisma Client API more complex. However, the advantage of using explicit many-to-many relations is that you can define extra fields on the relation table, which can be useful for storing additional information about the relation.

In your case, you're now connecting Pet to Owner through the OwnersOfPets model, which requires you to specify the petId and ownerId in the connect clause. This is why you can't use the unique name field of Owner to connect to the Pet anymore, because the connection is now being managed through the OwnersOfPets model. While the developer experience (DX) might be different when using explicit many-to-many relations compared to implicit ones, this is the expected behavior and not something you're doing wrong.

If this answers your question, it would be great if you could mark this Discussion as answered to indicate that it has been resolved.

Otherwise please let us know how else we can help you further or close the Discussion if it was resolved in some other way 🙏

model ReferCredit {
  id                              String         @id
  referrer                        String?
  referred                        String?        @unique
  User_ReferCredit_referredToUser User?          @relation("ReferCredit_referredToUser", fields: [referred], references: [id])
  User_ReferCredit_referrerToUser User?          @relation("ReferCredit_referrerToUser", fields: [referrer], references: [id])
}

model User {
  id                    String           @id
  ReferredToUser        ReferCredit?     @relation("ReferCredit_referredToUser")
  ReferrerToUser        ReferCredit[]    @relation("ReferCredit_referrerToUser")
}

This is what I have set up for something similar, maybe it'll help. In my case a user can be a referrer and referred. referrers can have many referred under them. Referred users can only show up once as a referred user.

You need to name the relations since you have two relations between same types (Driver <-> Shift and Driver <-> Zone both are connected by two relations each).

In cases like this Prisma asks you to name the relations which is what the error message you posted is about. I think this data model should work:

type Driver {
  id: ID! @unique
  zones: [Zone!] @relation(name: "DriverZones")
  shifts: [Shift!] @relation(name: "DriverShifts")
  preferredZone: Zone @relation(name: "PreferredZone")
  preferredShift: Shift @relation(name: "PreferredShift")
}


type Shift {
  id: ID! @unique 
  drivers: [Driver! ] @relation(name: "DriverShifts") 
}


type Zone {
  id: ID! @unique 
  drivers: [Driver! ] @relation(name: "DriverZones") 
}

you need to add relations to solve this issue as following one to many for coach relation and many to many for lesson users relation

// schema.prisma
generator client {
  provider = "prisma-client-js"
}

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

enum LessonState {
    ACTIVE
    CLOSED
}

model Lesson {
    id          String      @id @default(uuid()) @map("_id") @db.Uuid
    date        DateTime    @default(now())
    subject     String
    description String
    state       LessonState @default(ACTIVE)
    users       User[]   @relation(name: "lesson_users")
    coachId     String   @db.Uuid
    coach User  @relation(name: "coach", fields: [coachId], references: [id])
}

enum UserRoles {
    ADMIN
    USER
}

model User {
    id        String    @id @default(uuid()) @map("_id") @db.Uuid
    name      String
    surname   String
    password  String
    login     String    @unique
    birthDate DateTime
    role      UserRoles @default(USER)
    createdAt DateTime  @default(now())
    myLessons   Lesson[] @relation(name: "lesson_users")
    lessonsITeach    Lesson[] @relation(name: "coach")
}

The following query returns all lessons with a list of the users who participated in it and the the trainer

await prisma.lesson.findMany({
  include: {
    users: true,
    coach: true,
  },
});

to get ids of users that Lesson participated in lesson

await prisma.lesson.findFirst({
      include: {
        users: { select: { id: true } },
        coach: true,
      },
    });

to get all lessons the user participated in and what lessons the user teach

await prisma.user.findFirst({
  include: {
    myLessons: true,
    lessonsITeach: true,
  },
});

to get only ids

await prisma.user.findFirst({
  include: {
    myLessons: { select: { id: true } },
    lessonsITeach: { select: { id: true } },
  },
});