src/modules/task/
├── dto/
│   ├── create-task.dto.ts     # Schema Zod e DTO de criação
│   └── update-task.dto.ts     # Schema .partial() e DTO de atualização
├── task.constants.ts          # Códigos válidos de status/prioridade (TASK_STATUS_CODES, TASK_PRIORITY_CODES)
├── task.type.ts                # Interface Task (shape serializado da resposta)
├── task.controller.ts         # Controller REST com OpenAPI / Swagger
├── task.module.ts             # Módulo NestJS
├── task.service.ts            # Regras de negócio usando PrismaService
└── task.service.spec.ts       # Testes unitários mockando PrismaService

// prisma/schema.prisma
model Task {
  id          String       @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  title       String
  description String?
  statusId    Int
  status      TaskStatus   @relation(fields: [statusId], references: [id])
  priorityId  Int
  priority    TaskPriority @relation(fields: [priorityId], references: [id])
  dueDate     DateTime?
  ownerId     String?      @db.Uuid
  createdAt   DateTime     @default(now())
  updatedAt   DateTime     @updatedAt

  @@index([ownerId])
  @@index([statusId])
  @@index([priorityId])
  @@map("tasks")
}

// src/modules/task/task.constants.ts
export const TASK_STATUS_CODES = ['PENDING', 'IN_PROGRESS', 'COMPLETED', 'CANCELLED'] as const;
export type TaskStatusCode = (typeof TASK_STATUS_CODES)[number];

export const TASK_PRIORITY_CODES = ['LOW', 'MEDIUM', 'HIGH', 'URGENT'] as const;
export type TaskPriorityCode = (typeof TASK_PRIORITY_CODES)[number];

export const DEFAULT_TASK_STATUS: TaskStatusCode = 'PENDING';
export const DEFAULT_TASK_PRIORITY: TaskPriorityCode = 'MEDIUM';

// src/modules/task/dto/create-task.dto.ts
import { createZodDto } from 'nestjs-zod';
import { z } from 'zod';
import { TASK_PRIORITY_CODES, TASK_STATUS_CODES } from '../task.constants';

export const CreateTaskSchema = z.object({
  title: z.string().min(3).max(200).describe('Título da tarefa'),
  description: z.string().optional().describe('Descrição detalhada'),
  priority: z.enum(TASK_PRIORITY_CODES).optional().describe('Prioridade da tarefa'),
  status: z.enum(TASK_STATUS_CODES).optional().describe('Status da tarefa'),
  dueDate: z.string().date().optional().describe('Data de vencimento (YYYY-MM-DD)'),
});

export class CreateTaskDto extends createZodDto(CreateTaskSchema) {}

// src/modules/task/dto/update-task.dto.ts
import { createZodDto } from 'nestjs-zod';
import { CreateTaskSchema } from './create-task.dto';

export const UpdateTaskSchema = CreateTaskSchema.partial();

export class UpdateTaskDto extends createZodDto(UpdateTaskSchema) {}

// src/modules/task/task.service.ts
@Injectable()
export class TaskService {
  constructor(private readonly prisma: PrismaService) {}

  async create(createTaskDto: CreateTaskDto, ownerId?: string): Promise<Task> {
    const task = await this.prisma.task.create({
      data: {
        title: createTaskDto.title,
        description: createTaskDto.description ?? null,
        dueDate: createTaskDto.dueDate ? new Date(createTaskDto.dueDate) : null,
        ownerId: ownerId ?? null,
        status: { connect: { code: createTaskDto.status ?? DEFAULT_TASK_STATUS } },
        priority: { connect: { code: createTaskDto.priority ?? DEFAULT_TASK_PRIORITY } },
      },
      include: { status: true, priority: true },
    });
    return this.serialize(task);
  }

  async findOne(id: string): Promise<Task> {
    const task = await this.prisma.task.findUnique({
      where: { id },
      include: { status: true, priority: true },
    });
    if (!task) {
      throw new ResourceNotFoundException('Tarefa', id);
    }
    return this.serialize(task);
  }

  // findAll, update e remove seguem o mesmo padrão: this.prisma.task.*
}

// src/modules/task/task.controller.ts
@ApiTags('Tasks')
@ApiBearerAuth()
@Controller('tasks')
export class TaskController {
  constructor(private readonly taskService: TaskService) {}

  @Post()
  @ApiOperation({ summary: 'Criar uma nova tarefa' })
  @ApiResponse({ status: 201, description: 'Tarefa criada com sucesso' })
  create(
    @Body() createTaskDto: CreateTaskDto,
    @GetCurrentUser() user?: CurrentUser,
  ): Promise<Task> {
    return this.taskService.create(createTaskDto, user?.userId);
  }

  @Get()
  @ApiOperation({ summary: 'Listar tarefas paginadas' })
  @ApiResponse({ status: 200, description: 'Lista paginada de tarefas retornada' })
  findAll(@Query() query: PaginationQueryDto): Promise<PaginatedResponseDto<Task>> {
    return this.taskService.findAll(query);
  }

  @Get(':id')
  @ApiOperation({ summary: 'Buscar uma tarefa por ID' })
  @ApiResponse({ status: 200, description: 'Tarefa encontrada' })
  @ApiResponse({ status: 404, description: 'Tarefa não encontrada' })
  findOne(@Param('id', ParseUUIDPipe) id: string): Promise<Task> {
    return this.taskService.findOne(id);
  }

  @Patch(':id')
  @ApiOperation({ summary: 'Atualizar uma tarefa' })
  @ApiResponse({ status: 200, description: 'Tarefa atualizada' })
  @ApiResponse({ status: 404, description: 'Tarefa não encontrada' })
  update(
    @Param('id', ParseUUIDPipe) id: string,
    @Body() updateTaskDto: UpdateTaskDto,
  ): Promise<Task> {
    return this.taskService.update(id, updateTaskDto);
  }

  @Delete(':id')
  @ApiOperation({ summary: 'Remover uma tarefa' })
  @ApiResponse({ status: 204, description: 'Tarefa removida' })
  @ApiResponse({ status: 404, description: 'Tarefa não encontrada' })
  remove(@Param('id', ParseUUIDPipe) id: string): Promise<void> {
    return this.taskService.remove(id);
  }
}

const prisma = {
  task: {
    create: vi.fn(),
    findMany: vi.fn(),
    count: vi.fn(),
    findUnique: vi.fn(),
    update: vi.fn(),
    delete: vi.fn(),
  },
};

const module: TestingModule = await Test.createTestingModule({
  providers: [TaskService, { provide: PrismaService, useValue: prisma }],
}).compile();