Introduction to Prisma

Prisma is an ORM built around a schema DSL and a generated TypeScript client. You define models in schema.prisma, run generation, and get strongly typed database operations for CRUD, relations, filtering, and transactions.

Schema Shape

A Prisma schema contains a datasource, a generator, and models. Fields define scalar types, constraints, defaults, and database relationships.

const prismaSchemaExample = `
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}
`;

After changing the schema, run prisma generate so the client types match the models.

Basic CRUD

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

const prisma = new PrismaClient();

export async function createUser(email: string, name?: string) {
  try {
    return await prisma.user.create({
      data: { email, name },
    });
  } catch (error) {
    if (
      error instanceof Prisma.PrismaClientKnownRequestError &&
      error.code === "P2002"
    ) {
      throw new Error("Email is already registered.");
    }
    throw error;
  }
}

export async function findUserByEmail(email: string) {
  return prisma.user.findUnique({ where: { email } });
}

Prisma exposes findUnique, findMany, create, update, delete, and upsert. Unique lookups require fields marked @id or @unique.

Production Client Lifetime

Create one PrismaClient instance per long-running process. In development with hot reload, use a singleton pattern to avoid creating new clients on every module reload.

Further Learning

Search these terms to go deeper:

• “Prisma schema model attributes” — @id, @unique, defaults, and timestamps
• “PrismaClient CRUD TypeScript” — generated client query examples
• “Prisma P2002 unique constraint” — handling duplicate writes gracefully
• “Prisma singleton Next.js hot reload” — avoiding too many client instances in dev

Introduction to Prisma

Prisma is a popular tool that lets you talk to your database using regular, type-safe JavaScript/TypeScript instead of writing raw SQL. You describe your data once, and Prisma generates a client that knows exactly what fields and types you have.

Describe your data once

You write your models in a schema file, in a simple format:

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
}

After changing this file, run prisma generate — it builds a fully-typed client matching your schema exactly (autocomplete and all).

Basic operations (CRUD)

const prisma = new PrismaClient()

// create
await prisma.user.create({ data: { email: '[email protected]' } })

// find one
await prisma.user.findUnique({ where: { email: '[email protected]' } })

// find many
await prisma.user.findMany()

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

Your editor autocompletes every field, and TypeScript catches typos before you even run the code.

Handling duplicate errors

If you try to create a user with an email that’s already taken (marked @unique), Prisma throws a specific error you can catch and turn into a friendly message:

try {
  await prisma.user.create({ data: { email } })
} catch (error) {
  if (error.code === 'P2002') throw new Error('Email is already registered.')
  throw error
}

In one sentence

Prisma lets you define your data model once and get a fully-typed client for reading and writing — use findUnique/findMany/create/update, catch the P2002 error code for duplicate values, and keep just one PrismaClient instance running.

Want to go deeper?

Switch to Expert mode above for the full schema attributes and production client-lifetime patterns.