How to fix P2013: Missing the required argument for field in Prisma

Error:
Invalid `prisma.user.create()` invocation:
{
  data: {
    name: "Alice",
    posts: {}
    ~~~~~
  }
}
Missing the required argument for field `posts`.

// For a to-many relation (User has many Posts):
// You need ONE of these:
posts: {
  create: { title: "First Post" }           // Create new related records
}

posts: {
  connect: [{ id: 1 }, { id: 2 }]           // Connect to existing records
}

posts: {
  connectOrCreate: [                         // Connect or create
    {
      where: { id: 1 },
      create: { title: "Existing Post" }
    }
  ]
}

// For a to-one relation (Post belongs to User):
author: {
  create: { name: "Alice" }                 // Create new author
}

author: {
  connect: { id: 1 }                        // Connect to existing author
}

author: {
  connectOrCreate: {                        // Connect or create
    where: { id: 1 },
    create: { name: "Alice" }
  }
}

// ❌ WRONG: Missing required argument for 'posts' field
await prisma.user.create({
  data: {
    name: 'Alice',
    posts: {}  // Empty object - causes P2013
  }
});

// ✅ CORRECT: Use 'create' to make new posts
await prisma.user.create({
  data: {
    name: 'Alice',
    posts: {
      create: [
        { title: 'First Post' },
        { title: 'Second Post' }
      ]
    }
  }
});

// ✅ CORRECT: Use 'connect' to link existing posts
await prisma.user.create({
  data: {
    name: 'Alice',
    posts: {
      connect: [
        { id: 1 },
        { id: 2 }
      ]
    }
  }
});

// ✅ CORRECT: Use 'connectOrCreate' for flexibility
await prisma.user.create({
  data: {
    name: 'Alice',
    posts: {
      connectOrCreate: [
        {
          where: { id: 1 },
          create: { title: 'Existing Post' }
        },
        {
          where: { id: 999 },  // Won't exist, will create
          create: { title: 'New Post' }
        }
      ]
    }
  }
});

// In your Prisma schema:
model User {
  id      Int     @id @default(autoincrement())
  name    String
  profile Profile?  // Optional relation (to-one)
}

// ✅ CORRECT: Omit optional relation
await prisma.user.create({
  data: {
    name: 'Alice'
    // profile omitted - OK for optional relation
  }
});

// ✅ CORRECT: Explicitly set to null
await prisma.user.create({
  data: {
    name: 'Alice',
    profile: null  // Explicitly set optional relation to null
  }
});

// ❌ WRONG: Empty object for optional relation
await prisma.user.create({
  data: {
    name: 'Alice',
    profile: {}  // Still needs argument if provided
  }
});

// ✅ CORRECT: Provide argument for optional relation
await prisma.user.create({
  data: {
    name: 'Alice',
    profile: {
      create: { bio: 'Developer' }
    }
  }
});

// ❌ WRONG: Missing argument at nested level
await prisma.user.create({
  data: {
    name: 'Alice',
    posts: {
      create: [
        {
          title: 'Post',
          comments: {}  // Missing argument for comments field!
        }
      ]
    }
  }
});

// ✅ CORRECT: Complete nested structure
await prisma.user.create({
  data: {
    name: 'Alice',
    posts: {
      create: [
        {
          title: 'Post',
          comments: {
            create: [
              { content: 'First comment' },
              { content: 'Second comment' }
            ]
          }
        }
      ]
    }
  }
});

// ✅ CORRECT: Mix different operations
await prisma.user.create({
  data: {
    name: 'Alice',
    posts: {
      create: [
        {
          title: 'New Post',
          comments: {
            connect: [{ id: 1 }]  // Connect existing comments
          }
        }
      ],
      connect: [{ id: 2 }]  // Also connect existing post
    }
  }
});

async function testRelationQueries() {
  try {
    // Test basic create with nested relation
    const userWithPosts = await prisma.user.create({
      data: {
        name: 'Test User',
        email: '[email protected]',
        posts: {
          create: [
            { title: 'Test Post 1', content: 'Content 1' },
            { title: 'Test Post 2', content: 'Content 2' }
          ]
        }
      },
      include: { posts: true }
    });
    console.log('Create with nested posts works:', userWithPosts);

    // Test connect to existing relations
    const connectedUser = await prisma.user.create({
      data: {
        name: 'Connected User',
        email: '[email protected]',
        posts: {
          connect: [{ id: 1 }]  // Assuming post with id=1 exists
        }
      },
      include: { posts: true }
    });
    console.log('Connect to existing posts works:', connectedUser);

    // Test update with relation modification
    const updatedUser = await prisma.user.update({
      where: { id: userWithPosts.id },
      data: {
        posts: {
          create: { title: 'Additional Post' }
        }
      },
      include: { posts: true }
    });
    console.log('Update with new post works:', updatedUser);

  } catch (error) {
    console.error('Relation query failed:', error.message);
    console.error('Full error:', error);
  }
}