Your First Conversation

I need a task management application for my team

Yes, tasks should be organized into projects. 
Each task needs a title, description, status (todo, in progress, done), 
priority (low, medium, high), assignee, and due date. 
Team members should be able to create and edit tasks.

  - Project
  - Task (fields: title, description, status, priority, dueDate)
  - TeamMember

  - Project → Tasks (one-to-many)
  - Task → TeamMember (many-to-one: assignee)

Yes, we need two roles: admin and member. 
Admins can create projects and invite members. 
Members can only work on tasks in their projects. 
Add comments on tasks for collaboration.

That's exactly right! Also add:
- Task attachments for files
- Email notifications when tasks are assigned
- Activity log to track changes

Entities:
  User:
    - id: uuid
    - email: string (unique)
    - name: string
    - role: enum [admin, member]
    - createdAt: datetime
    
  Project:
    - id: uuid
    - name: string
    - description: text
    - ownerId: uuid (ref: User)
    - createdAt: datetime
    
  Task:
    - id: uuid
    - title: string
    - description: text
    - status: enum [todo, in_progress, done]
    - priority: enum [low, medium, high]
    - projectId: uuid (ref: Project)
    - assigneeId: uuid (ref: User)
    - dueDate: datetime
    - createdAt: datetime
    - updatedAt: datetime
    
  Comment:
    - id: uuid
    - content: text
    - taskId: uuid (ref: Task)
    - authorId: uuid (ref: User)
    - createdAt: datetime
    
  Attachment:
    - id: uuid
    - filename: string
    - url: string
    - taskId: uuid (ref: Task)
    - uploadedBy: uuid (ref: User)
    - createdAt: datetime
    
  ActivityLog:
    - id: uuid
    - action: string
    - entityType: string
    - entityId: uuid
    - userId: uuid (ref: User)
    - metadata: json
    - createdAt: datetime

Relationships:
  - User → Projects (many-to-many via membership)
  - Project → Tasks (one-to-many)
  - Task → Comments (one-to-many)
  - Task → Attachments (one-to-many)
  - User → ActivityLogs (one-to-many)

model User {
  id        String   @id @default(uuid())
  email     String   @unique
  name      String
  role      Role     @default(MEMBER)
  createdAt DateTime @default(now())
  
  ownedProjects Project[]      @relation("ProjectOwner")
  projects      ProjectMember[]
  assignedTasks Task[]
  comments      Comment[]
  attachments   Attachment[]
  activities    ActivityLog[]
}

model Project {
  id          String   @id @default(uuid())
  name        String
  description String?
  ownerId     String
  owner       User     @relation("ProjectOwner", fields: [ownerId], references: [id])
  createdAt   DateTime @default(now())
  
  tasks   Task[]
  members ProjectMember[]
}

model Task {
  id          String    @id @default(uuid())
  title       String
  description String?
  status      Status    @default(TODO)
  priority    Priority  @default(MEDIUM)
  projectId   String
  project     Project   @relation(fields: [projectId], references: [id])
  assigneeId  String?
  assignee    User?     @relation(fields: [assigneeId], references: [id])
  dueDate     DateTime?
  createdAt   DateTime  @default(now())
  updatedAt   DateTime  @updatedAt
  
  comments    Comment[]
  attachments Attachment[]
}

enum Role {
  ADMIN
  MEMBER
}

enum Status {
  TODO
  IN_PROGRESS
  DONE
}

enum Priority {
  LOW
  MEDIUM
  HIGH
}

// app/api/tasks/route.ts
export async function GET(request: Request) {
  const tasks = await prisma.task.findMany({
    include: {
      assignee: true,
      project: true,
      comments: { take: 5 }
    }
  });
  return Response.json(tasks);
}

export async function POST(request: Request) {
  const data = await request.json();
  const task = await prisma.task.create({
    data: {
      ...data,
      // Send notification
      // Log activity
    }
  });
  return Response.json(task);
}

Add a dashboard that shows:
- Tasks due today
- Overdue tasks
- Team workload
- Project progress