CRUD operations with Prisma in NextJS

Introduction

CRUD operations let you create, read, update, and delete data in your app. Prisma helps you do this easily with your database.

When you want to save new user info in your app.

When you need to show a list of items from your database.

When you want to change details of something already saved.

When you want to remove data that is no longer needed.

When building any app that stores and manages data.

Syntax

NextJS

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

const prisma = new PrismaClient();

// Create
await prisma.modelName.create({ data: { /* fields */ } });

// Read
await prisma.modelName.findMany();
await prisma.modelName.findUnique({ where: { id: value } });

// Update
await prisma.modelName.update({ where: { id: value }, data: { /* fields */ } });

// Delete
await prisma.modelName.delete({ where: { id: value } });

Replace modelName with your actual Prisma model name (like user or post).

Use await because Prisma operations are asynchronous.

Examples

This creates a new user with name and email.

NextJS

await prisma.user.create({ data: { name: 'Alice', email: '[e-mail]' } });

This fetches all users from the database.

NextJS

const users = await prisma.user.findMany();

This updates the user with id 1 to have a new name.

NextJS

await prisma.user.update({ where: { id: 1 }, data: { name: 'Alice Updated' } });

This deletes the user with id 1.

NextJS

await prisma.user.delete({ where: { id: 1 } });

Sample Program

This program shows all four CRUD operations with Prisma on a user model. It creates a user, reads all users, updates the created user, then deletes it. Finally, it prints the results at each step.

NextJS

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

const prisma = new PrismaClient();

async function main() {
  // Create a new user
  const newUser = await prisma.user.create({
    data: { name: 'Bob', email: '[e-mail]' }
  });

  // Read all users
  const allUsers = await prisma.user.findMany();

  // Update the new user's name
  const updatedUser = await prisma.user.update({
    where: { id: newUser.id },
    data: { name: 'Bobby' }
  });

  // Delete the user
  await prisma.user.delete({ where: { id: updatedUser.id } });

  // Return all users after deletion
  const usersAfterDelete = await prisma.user.findMany();

  console.log('Created User:', newUser);
  console.log('All Users:', allUsers);
  console.log('Updated User:', updatedUser);
  console.log('Users After Delete:', usersAfterDelete);
}

main()
  .catch(e => console.error(e))
  .finally(async () => {
    await prisma.$disconnect();
  });

Important Notes

Always disconnect Prisma client with prisma.$disconnect() to avoid open connections.

Use try/catch or .catch() to handle errors in async Prisma calls.

Make sure your Prisma schema is set up and migrated before running CRUD operations.

Summary

CRUD means Create, Read, Update, Delete data.

Prisma provides easy methods to do CRUD with your database.

Use async/await and proper error handling when working with Prisma.

Practice

1. What does the prisma.user.create() method do in Next.js with Prisma?

easy

A. It adds a new user record to the database.

B. It fetches all user records from the database.

C. It updates an existing user record.

D. It deletes a user record from the database.

Solution

1. Step 1: Understand the method name

   The method create() is used to add new data in Prisma.

2. Step 2: Match method to CRUD operation

   Creating means adding new records, so prisma.user.create() adds a new user.

3. Final Answer:

   It adds a new user record to the database. -> Option A

4. Quick Check:

   Create method = Add new record [OK]

Hint: Create method adds new data, not read or delete [OK]

Common Mistakes:

• Confusing create() with findMany() which reads data
• Thinking create() updates existing records
• Assuming create() deletes records

2. Which of the following is the correct syntax to update a user with id 5 using Prisma in Next.js?

easy

A. prisma.user.edit({ where: { id: 5 }, data: { name: 'Alice' } })

B. prisma.user.modify({ id: 5, name: 'Alice' })

C. prisma.user.update({ where: { id: 5 }, data: { name: 'Alice' } })

D. prisma.user.change({ id: 5, data: { name: 'Alice' } })

Solution

1. Step 1: Identify Prisma update syntax

   Prisma uses update() with where and data keys to update records.

2. Step 2: Check option correctness

   Only prisma.user.update({ where: { id: 5 }, data: { name: 'Alice' } }) uses correct method update() and proper keys where and data.

3. Final Answer:

   prisma.user.update({ where: { id: 5 }, data: { name: 'Alice' } }) -> Option C

4. Quick Check:

   Update method uses where and data keys [OK]

Hint: Update uses update({ where, data }) syntax [OK]

Common Mistakes:

• Using non-existent methods like modify(), change(), edit()
• Missing where or data keys in update()
• Passing id directly without where object

3. Given this code snippet in Next.js with Prisma:

const users = await prisma.user.findMany({ where: { active: true } });
console.log(users.length);

What will console.log(users.length) output?

medium

A. Always 0, because findMany returns undefined.

B. The total number of users, active or not.

C. An error because findMany needs data key.

D. The number of active users in the database.

Solution

1. Step 1: Understand findMany with where filter

   The findMany() method returns an array of records matching the where condition.

2. Step 2: Analyze the filter condition

   Only users with active: true are returned, so users.length is count of active users.

3. Final Answer:

   The number of active users in the database. -> Option D

4. Quick Check:

   findMany with where returns filtered array [OK]

Hint: findMany returns array; length counts filtered records [OK]

Common Mistakes:

• Thinking findMany returns undefined or error
• Ignoring the where filter effect
• Assuming it returns all users without filter

4. Identify the error in this Prisma delete operation:

await prisma.user.delete({ id: 10 });

medium

A. Missing the 'where' key wrapping the id.

B. Using delete() instead of remove().

C. id should be a string, not a number.

D. delete() cannot be used with await.

Solution

1. Step 1: Check delete() method syntax

   Prisma's delete() requires an object with a where key specifying the record to delete.

2. Step 2: Identify missing where key

   The code passes { id: 10 } directly, missing where: { id: 10 }.

3. Final Answer:

   Missing the 'where' key wrapping the id. -> Option A

4. Quick Check:

   Delete needs where key with id [OK]

Hint: Delete needs where: { id } object, not just id [OK]

Common Mistakes:

• Omitting where key in delete()
• Using remove() which does not exist in Prisma
• Thinking id type must be string always
• Believing delete() can't be awaited

5. You want to update a user's email only if the user exists, otherwise create a new user with that email. Which Prisma method best fits this use case in Next.js?

hard

A. prisma.user.create({ data: { email } })

B. prisma.user.upsert({ where: { email }, update: { email }, create: { email } })

C. prisma.user.update({ where: { email }, data: { email } })

D. prisma.user.findUnique({ where: { email } })

Solution

1. Step 1: Understand the upsert method

   Upsert updates if record exists, else creates new one in Prisma.

2. Step 2: Match use case to method

   Since we want to update or create based on existence, upsert() fits perfectly.

3. Final Answer:

   prisma.user.upsert({ where: { email }, update: { email }, create: { email } }) -> Option B

4. Quick Check:

   Upsert = update or create [OK]

Hint: Use upsert to update or create in one call [OK]

Common Mistakes:

• Using update() alone which fails if user missing
• Using create() alone which fails if user exists
• Using findUnique() which only reads data