How to fix P2002: Unique constraint failed on the fields in Prisma

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

try {
  await prisma.user.create({
    data: {
      email: '[email protected]',
      name: 'Alice'
    }
  });
} catch (error) {
  if (error instanceof Prisma.PrismaClientKnownRequestError) {
    if (error.code === 'P2002') {
      console.log('Unique constraint failed on:', error.meta?.target);
      // Output: Unique constraint failed on: ['email']
    }
  }
}

async function createUserSafely(email: string, name: string) {
  // Check if user with this email already exists
  const existingUser = await prisma.user.findUnique({
    where: { email }
  });

  if (existingUser) {
    throw new Error(`User with email ${email} already exists`);
    // Or return the existing user
    // return existingUser;
  }

  // Safe to create now
  return await prisma.user.create({
    data: { email, name }
  });
}

const user = await prisma.user.upsert({
  where: { email: '[email protected]' },
  update: {
    name: 'Alice Updated'
  },
  create: {
    email: '[email protected]',
    name: 'Alice'
  }
});

// Schema: @@unique([userId, postId])
const like = await prisma.like.upsert({
  where: {
    userId_postId: {
      userId: 1,
      postId: 100
    }
  },
  update: {
    createdAt: new Date()
  },
  create: {
    userId: 1,
    postId: 100
  }
});

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

async function createUser(email: string, name: string) {
  try {
    return await prisma.user.create({
      data: { email, name }
    });
  } catch (error) {
    if (error instanceof Prisma.PrismaClientKnownRequestError) {
      if (error.code === 'P2002') {
        const target = error.meta?.target as string[] | undefined;
        const field = target?.join(', ') || 'unknown field';

        throw new Error(
          `A user with this ${field} already exists. Please use a different value.`
        );
      }
    }
    throw error;
  }
}

app.post('/users', async (req, res) => {
  try {
    const user = await createUser(req.body.email, req.body.name);
    res.status(201).json(user);
  } catch (error) {
    if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
      return res.status(409).json({
        error: 'Conflict',
        message: 'A user with this email already exists'
      });
    }
    res.status(500).json({ error: 'Internal server error' });
  }
});

async function upsertWithRetry<T>(
  operation: () => Promise<T>,
  maxRetries: number = 3,
  delay: number = 100
): Promise<T> {
  let lastError: any;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      if (error instanceof Prisma.PrismaClientKnownRequestError &&
          error.code === 'P2002') {
        lastError = error;
        // Wait before retrying with exponential backoff
        await new Promise(resolve =>
          setTimeout(resolve, delay * Math.pow(2, attempt))
        );
        continue;
      }
      throw error;
    }
  }

  throw lastError;
}

// Usage
const user = await upsertWithRetry(() =>
  prisma.user.upsert({
    where: { email: '[email protected]' },
    update: { name: 'Alice' },
    create: { email: '[email protected]', name: 'Alice' }
  })
);

model User {
  id       String   @id @default(cuid())
  email    String   @unique  // Single field unique constraint
  username String   @unique
  name     String
}

model Post {
  id        String   @id @default(cuid())
  title     String
  slug      String
  authorId  String

  // Compound unique constraint - combination must be unique
  @@unique([slug, authorId])
}

model UserProfile {
  userId    String   @unique  // One-to-one relation
  bio       String?
  user      User     @relation(fields: [userId], references: [id])
}

npx prisma migrate dev --name add-unique-constraint