Query polymorphic tables' related tables

[piscopancer]

Currently I got 2 models representing subtype of Notification and they both have different relations to group model and course model accordingly

model Notification {
  id         Int      @id @default(autoincrement())
  createdAt  DateTime @default(now())
  type       String
  senderId   Int
  sender     User     @relation("user-notification-sent", fields: [senderId], references: [id], onDelete: Cascade)
  receiverId Int
  receiver   User     @relation("user-notification-received", fields: [receiverId], references: [id], onDelete: Cascade)

  @@delegate (type)
}

model AddedToGroupNotification extends Notification {
  groupId Int
  group   Group @relation(fields: [groupId], references: [id], onDelete: Cascade)
}

model AddedToCourseNotification  extends Notification {
  courseId Int
  course   Course @relation(fields: [courseId], references: [id], onDelete: Cascade)
}

• AddedToGroupNotification has reference to group (and I need to query group too to show it's title in the notification),
• AddedToCourseNotification has reference to course (and I need to query course too to show it's title in the notification).

This is how I query all notifications

export async function queryNotifications(userId: number) {
  return db.notification.findMany({
    where: {
      receiverId: userId,
    },
    include: {
      // I expected I would be able to include `group` and `course` somewhere here 😟
      sender: {
        select: {
          name: true,
          surname: true,
          middlename: true,
        },
      },
    },
  })
}

And this is how I need to query every type of Notification separately, based on what they have

• AddedToCourseNotification

  db.addedToCourseNotification.findMany({
    include: {
      course: true
    }
  })

• AddedToGroupNotification

  db.addedToGroupNotification.findMany({
    include: {
      group: true
    }
  })

What's the best option I can do here? I really need to include

• sender from the Notification parent model (I already do it),
• course (if type is AddedToCourseNotification),
• group (if type is AddedToGroupNotification).

This way I will be able to display the title of the course and many other fields of course model in my "general use" component below

[piscopancer]

I attach my temporary solution, please explain what I am doing wrong or right and how it can be improved or if there is a better way to do it

export function getSharedNotificationsFindManyArgs(receiverId: number) {
  return {
    where: {
      receiverId,
    },
    include: {
      sender: {
        select: {
          id: true,
          name: true,
          surname: true,
          middlename: true,
        },
      },
    },
  } satisfies Prisma.NotificationFindManyArgs
}

export async function queryNotifications(receiverId: number) {
  const { where, include } = getSharedNotificationsFindManyArgs(receiverId)
  const notifications = await db.$transaction(async (tx) => {
    const course = await tx.addedToCourseNotification.findMany({
      where,
      include: {
        ...include,
        course: true,
      },
    })
    const group = await tx.addedToGroupNotification.findMany({
      where,
      include: {
        ...include,
        group: true,
      },
    })
    return [course, group]
  })
  return notifications.flat()
}

The problem I'm encountering with this approach is that I cannot discriminate over type inside my component to get either group or course respectively. I am still researching on the solution