Prisma Relations & Queries

Prisma relations model how records connect: users own posts, posts have tags, profiles belong to users. Relation fields make those connections type-safe in reads and writes, but you still need to control payload size and query shape.

Relation Definitions

One-to-many relations use a foreign key on the child model. Many-to-many can be implicit for simple join tables or explicit when the join itself has fields.

const schema = `
model User {
  id    String @id @default(cuid())
  email String @unique
  posts Post[]
}

model Post {
  id       String @id @default(cuid())
  title    String
  authorId String
  author   User   @relation(fields: [authorId], references: [id])
}
`;

Include And Select

Use include to eager-load relations. Use select to return only fields the client needs.

import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

export async function getUserProfile(userId: string) {
  return prisma.user.findUnique({
    where: { id: userId },
    select: {
      id: true,
      email: true,
      posts: {
        select: { id: true, title: true },
        take: 10,
      },
    },
  });
}

Projection keeps API responses smaller and makes accidental data exposure less likely.

Nested Writes

Nested writes let you create or connect related records in one operation.

export async function createPostForUser(userId: string, title: string) {
  return prisma.post.create({
    data: {
      title,
      author: {
        connect: { id: userId },
      },
    },
  });
}

Use connect for existing records, create for new child records, and relation filters such as some, every, and none when querying based on related rows.

Further Learning

Search these terms to go deeper:

• “Prisma one to many relation” — schema structure for foreign-key relationships
• “Prisma include vs select” — eager loading compared with field projection
• “Prisma nested create connect” — relation writes in a single operation
• “Prisma relation filters some every none” — filtering records by related data

Prisma Relations & Queries

Real data is connected — a user has posts, a post has tags. Prisma relations let you describe those connections once and then fetch related data together, in a type-safe way.

Describing a connection

model User {
  id    String @id @default(cuid())
  posts Post[]           // one user has many posts
}

model Post {
  id       String @id @default(cuid())
  authorId String
  author   User   @relation(fields: [authorId], references: [id])
}

Fetching related data together

Use include to grab related records in the same query — no separate lookups needed:

await prisma.user.findUnique({
  where: { id: userId },
  include: { posts: true }   // get the user AND their posts, one query
})

Or use select to only grab specific fields (keeps responses smaller and avoids accidentally leaking data you didn’t mean to send):

await prisma.user.findUnique({
  where: { id: userId },
  select: { id: true, email: true, posts: { select: { title: true } } }
})

Creating connected records at once

You can create a new record and link it to an existing one, in a single call:

await prisma.post.create({
  data: {
    title: 'Hello world',
    author: { connect: { id: userId } }   // link to the existing user
  }
})

connect links to something that already exists; create (nested) makes a brand-new related record at the same time.

In one sentence

Prisma relations connect models (like a user to their posts) — use include to fetch related data in one query, select to grab only the fields you need, and connect/nested create to link or create related records in a single write.

Want to go deeper?

Switch to Expert mode above for many-to-many relations and relation filters (some, every, none).