How to fix P2012: Missing a required value in Prisma

Error:
Invalid `prisma.user.create()` invocation:
{
  data: {
    email: "[email protected]"
  }
}

Missing a required value at `User.name`.

model User {
  id       String   @id @default(cuid())
  email    String   // Required (no ? modifier)
  name     String   // Required (no ? modifier)
  bio      String?  // Optional (has ? modifier)
  age      Int?     // Optional
  createdAt DateTime @default(now())  // Has default value
}

// ❌ WRONG: Missing required 'name' field
const user = await prisma.user.create({
  data: {
    email: '[email protected]'
    // name is missing but required!
  }
});

// ✅ CORRECT: Provide all required fields
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice Johnson'
    // Optional fields (bio, age) can be omitted
  }
});

// ✅ ALSO CORRECT: Include optional fields if needed
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice Johnson',
    bio: 'Software developer',
    age: 28
  }
});

// ✅ CORRECT: Update only the fields you need
const updated = await prisma.user.update({
  where: { id: '123' },
  data: {
    bio: 'New bio'  // Only update bio
    // Other fields are unchanged - no P2012 error
  }
});

// ✅ CORRECT: Update multiple fields
const updated = await prisma.user.update({
  where: { id: '123' },
  data: {
    name: 'Alice Updated',
    bio: 'Software architect'
  }
});

// ❌ WRONG: This would cause P2012 if you're using raw query
// Don't pass null to required fields in updates - causes data loss
const updated = await prisma.user.update({
  where: { id: '123' },
  data: {
    name: null  // ❌ Type error AND runtime error if allowed
  }
});

model User {
  id       String   @id @default(cuid())
  email    String   // Required
  name     String   // Required
  bio      String?  // Optional - can be null or undefined
  age      Int?     // Optional
  phone    String?  // Optional phone number
}

// ✅ CORRECT: Optional field can be omitted
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice'
    // bio is optional, can be omitted
  }
});

// ✅ ALSO CORRECT: Explicitly set optional field
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice',
    bio: 'Developer'  // Explicitly provided
  }
});

// ✅ ALSO CORRECT: Set optional field to null
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice',
    bio: null  // Explicitly null
  }
});

model User {
  id        String   @id @default(cuid())
  email     String
  name      String
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  status    String   @default("active")
  score     Int      @default(0)
}

// ✅ CORRECT: Default fields are auto-populated
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice'
    // id, createdAt, updatedAt, status, score are all auto-generated
  }
});

// The created record will have:
// {
//   id: 'cuid_value',
//   email: '[email protected]',
//   name: 'Alice',
//   createdAt: 2024-01-15T10:30:00Z,
//   updatedAt: 2024-01-15T10:30:00Z,
//   status: 'active',
//   score: 0
// }

interface CreateUserInput {
  email: string;
  name: string;
  bio?: string;  // Optional
  age?: number;  // Optional
}

async function createUserSafely(input: CreateUserInput) {
  // Type safety ensures required fields are provided
  const user = await prisma.user.create({
    data: {
      email: input.email,
      name: input.name,
      ...(input.bio && { bio: input.bio }),  // Only include if provided
      ...(input.age && { age: input.age })
    }
  });
  return user;
}

// ✅ CORRECT: Provide required fields
await createUserSafely({
  email: '[email protected]',
  name: 'Alice',
  bio: 'Developer'
});

// ❌ WRONG: Missing required field
await createUserSafely({
  email: '[email protected]'
  // name is missing - TypeScript error!
});

import { z } from 'zod';

const CreateUserSchema = z.object({
  email: z.string().email('Invalid email'),
  name: z.string().min(1, 'Name is required'),
  bio: z.string().optional(),
  age: z.number().positive().optional()
});

async function createUserWithValidation(data: unknown) {
  // Validate data structure
  const validated = CreateUserSchema.parse(data);

  // All required fields are guaranteed to exist
  const user = await prisma.user.create({
    data: validated
  });
  return user;
}

// Usage with API endpoint
app.post('/users', async (req, res) => {
  try {
    const user = await createUserWithValidation(req.body);
    res.status(201).json(user);
  } catch (error) {
    if (error instanceof z.ZodError) {
      return res.status(400).json({
        error: 'Validation failed',
        details: error.errors
      });
    }
    if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2012') {
      return res.status(400).json({
        error: 'Missing required field',
        message: error.message
      });
    }
    res.status(500).json({ error: 'Server error' });
  }
});