feat(tasks): implement CRUD endpoints with Supabase integration

backend-api/src/app.module.ts

@@ -10,6 +10,7 @@ import jwtConfig from './config/jwt.config';
 import { SupabaseService } from './config/supabase.service';
 import { JwtStrategy } from './auth/strategies/jwt.strategy';
 import { AuthModule } from './auth/auth.module';
+import { TasksModule } from './tasks/tasks.module';
 import * as Joi from 'joi';
 
 @Module({
@@ -40,6 +41,7 @@ import * as Joi from 'joi';
       }),
     }),
     AuthModule,
+    TasksModule,
   ],
   controllers: [AppController],
   providers: [AppService, SupabaseService, JwtStrategy],

backend-api/src/tasks/dto/create-task.dto.ts

@@ -0,0 +1,30 @@
+import { IsString, IsBoolean, IsOptional, MaxLength, MinLength } from 'class-validator';
+
+export class CreateTaskDto {
+  @IsString({ message: 'Título deve ser uma string' })
+  @MinLength(3, { message: 'Título deve ter no mínimo 3 caracteres' })
+  @MaxLength(255, { message: 'Título pode ter no máximo 255 caracteres' })
+  title: string;
+
+  @IsOptional()
+  @IsString({ message: 'Descrição deve ser uma string' })
+  @MaxLength(2000, { message: 'Descrição pode ter no máximo 2000 caracteres' })
+  description?: string;
+
+  @IsOptional()
+  @IsBoolean({ message: 'Concluído deve ser um booleano' })
+  completed?: boolean = false;
+
+  @IsOptional()
+  @IsString({ message: 'Data de vencimento deve ser uma string ISO' })
+  dueDate?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Categoria deve ser uma string' })
+  @MaxLength(50, { message: 'Categoria pode ter no máximo 50 caracteres' })
+  category?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Prioridade deve ser uma string' })
+  priority?: 'low' | 'medium' | 'high' = 'medium';
+}

backend-api/src/tasks/dto/update-task.dto.ts

@@ -0,0 +1,31 @@
+import { IsString, IsBoolean, IsOptional, MaxLength, MinLength } from 'class-validator';
+
+export class UpdateTaskDto {
+  @IsOptional()
+  @IsString({ message: 'Título deve ser uma string' })
+  @MinLength(3, { message: 'Título deve ter no mínimo 3 caracteres' })
+  @MaxLength(255, { message: 'Título pode ter no máximo 255 caracteres' })
+  title?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Descrição deve ser uma string' })
+  @MaxLength(2000, { message: 'Descrição pode ter no máximo 2000 caracteres' })
+  description?: string;
+
+  @IsOptional()
+  @IsBoolean({ message: 'Concluído deve ser um booleano' })
+  completed?: boolean;
+
+  @IsOptional()
+  @IsString({ message: 'Data de vencimento deve ser uma string ISO' })
+  dueDate?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Categoria deve ser uma string' })
+  @MaxLength(50, { message: 'Categoria pode ter no máximo 50 caracteres' })
+  category?: string;
+
+  @IsOptional()
+  @IsString({ message: 'Prioridade deve ser uma string' })
+  priority?: 'low' | 'medium' | 'high';
+}

backend-api/src/tasks/tasks.controller.ts

@@ -0,0 +1,80 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+  UseGuards,
+  Query,
+} from '@nestjs/common';
+import { TasksService } from './tasks.service';
+import { CreateTaskDto } from './dto/create-task.dto';
+import { UpdateTaskDto } from './dto/update-task.dto';
+import { JwtAuthGuard } from '../auth/guards/jwt.guard';
+import { CurrentUser } from '../common/decorators/current-user.decorator';
+
+@Controller('tasks')
+@UseGuards(JwtAuthGuard)
+export class TasksController {
+  constructor(private readonly tasksService: TasksService) {}
+
+  @Post()
+  create(
+    @CurrentUser() userId: string,
+    @Body() createTaskDto: CreateTaskDto,
+  ) {
+    return this.tasksService.create(userId, createTaskDto);
+  }
+
+  @Get()
+  findAll(
+    @CurrentUser() userId: string,
+    @Query('completed') completed?: string,
+    @Query('category') category?: string,
+    @Query('priority') priority?: string,
+    @Query('sortBy') sortBy?: 'created_at' | 'due_date' | 'priority',
+    @Query('order') order?: 'asc' | 'desc',
+  ) {
+    const filters = {
+      completed: completed === 'true' ? true : completed === 'false' ? false : undefined,
+      category,
+      priority,
+      sortBy,
+      order,
+    };
+
+    return this.tasksService.findAll(userId, filters);
+  }
+
+  @Get('stats')
+  getStats(@CurrentUser() userId: string) {
+    return this.tasksService.getStats(userId);
+  }
+
+  @Get(':id')
+  findOne(
+    @Param('id') id: string,
+    @CurrentUser() userId: string,
+  ) {
+    return this.tasksService.findOne(id, userId);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id') id: string,
+    @CurrentUser() userId: string,
+    @Body() updateTaskDto: UpdateTaskDto,
+  ) {
+    return this.tasksService.update(id, userId, updateTaskDto);
+  }
+
+  @Delete(':id')
+  remove(
+    @Param('id') id: string,
+    @CurrentUser() userId: string,
+  ) {
+    return this.tasksService.remove(id, userId);
+  }
+}

backend-api/src/tasks/tasks.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { TasksService } from './tasks.service';
+import { TasksController } from './tasks.controller';
+import { SupabaseService } from '../config/supabase.service';
+
+@Module({
+  providers: [TasksService, SupabaseService],
+  controllers: [TasksController],
+  exports: [TasksService],
+})
+export class TasksModule {}

backend-api/src/tasks/tasks.service.ts

@@ -0,0 +1,203 @@
+import { Injectable, BadRequestException, NotFoundException, ForbiddenException } from '@nestjs/common';
+import { SupabaseService } from '../config/supabase.service';
+import { CreateTaskDto } from './dto/create-task.dto';
+import { UpdateTaskDto } from './dto/update-task.dto';
+
+@Injectable()
+export class TasksService {
+  constructor(private supabaseService: SupabaseService) {}
+
+  async create(userId: string, createTaskDto: CreateTaskDto) {
+    const { data, error } = await this.supabaseService
+      .getClient()
+      .from('tasks')
+      .insert([
+        {
+          title: createTaskDto.title,
+          description: createTaskDto.description || null,
+          completed: createTaskDto.completed || false,
+          due_date: createTaskDto.dueDate || null,
+          category: createTaskDto.category || null,
+          priority: createTaskDto.priority || 'medium',
+          user_id: userId,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+        },
+      ])
+      .select();
+
+    if (error) {
+      throw new BadRequestException(`Erro ao criar tarefa: ${error.message}`);
+    }
+
+    return {
+      success: true,
+      message: 'Tarefa criada com sucesso',
+      data: data?.[0],
+    };
+  }
+
+  async findAll(
+    userId: string,
+    filters?: {
+      completed?: boolean;
+      category?: string;
+      priority?: string;
+      sortBy?: 'created_at' | 'due_date' | 'priority';
+      order?: 'asc' | 'desc';
+    },
+  ) {
+    let query = this.supabaseService
+      .getClient()
+      .from('tasks')
+      .select('*')
+      .eq('user_id', userId);
+
+    // Aplicar filtros
+    if (filters?.completed !== undefined) {
+      query = query.eq('completed', filters.completed);
+    }
+
+    if (filters?.category) {
+      query = query.eq('category', filters.category);
+    }
+
+    if (filters?.priority) {
+      query = query.eq('priority', filters.priority);
+    }
+
+    // Ordenação
+    const sortBy = filters?.sortBy || 'created_at';
+    const order = filters?.order || 'desc';
+    query = query.order(sortBy, { ascending: order === 'asc' });
+
+    const { data, error } = await query;
+
+    if (error) {
+      throw new BadRequestException(`Erro ao buscar tarefas: ${error.message}`);
+    }
+
+    return {
+      success: true,
+      message: 'Tarefas recuperadas com sucesso',
+      count: data?.length || 0,
+      data: data || [],
+    };
+  }
+
+  async findOne(id: string, userId: string) {
+    const { data, error } = await this.supabaseService
+      .getClient()
+      .from('tasks')
+      .select('*')
+      .eq('id', id)
+      .eq('user_id', userId)
+      .single();
+
+    if (error || !data) {
+      throw new NotFoundException('Tarefa não encontrada');
+    }
+
+    return {
+      success: true,
+      message: 'Tarefa recuperada com sucesso',
+      data,
+    };
+  }
+
+  async update(id: string, userId: string, updateTaskDto: UpdateTaskDto) {
+    // Verificar se tarefa existe e pertence ao usuário
+    const { data: existingTask, error: fetchError } = await this.supabaseService
+      .getClient()
+      .from('tasks')
+      .select('*')
+      .eq('id', id)
+      .eq('user_id', userId)
+      .single();
+
+    if (fetchError || !existingTask) {
+      throw new NotFoundException('Tarefa não encontrada');
+    }
+
+    // Atualizar tarefa
+    const { data, error } = await this.supabaseService
+      .getClient()
+      .from('tasks')
+      .update({
+        ...updateTaskDto,
+        updated_at: new Date().toISOString(),
+      })
+      .eq('id', id)
+      .eq('user_id', userId)
+      .select();
+
+    if (error) {
+      throw new BadRequestException(`Erro ao atualizar tarefa: ${error.message}`);
+    }
+
+    return {
+      success: true,
+      message: 'Tarefa atualizada com sucesso',
+      data: data?.[0],
+    };
+  }
+
+  async remove(id: string, userId: string) {
+    // Verificar se tarefa existe e pertence ao usuário
+    const { data: existingTask, error: fetchError } = await this.supabaseService
+      .getClient()
+      .from('tasks')
+      .select('*')
+      .eq('id', id)
+      .eq('user_id', userId)
+      .single();
+
+    if (fetchError || !existingTask) {
+      throw new NotFoundException('Tarefa não encontrada');
+    }
+
+    // Deletar tarefa
+    const { error } = await this.supabaseService
+      .getClient()
+      .from('tasks')
+      .delete()
+      .eq('id', id)
+      .eq('user_id', userId);
+
+    if (error) {
+      throw new BadRequestException(`Erro ao deletar tarefa: ${error.message}`);
+    }
+
+    return {
+      success: true,
+      message: 'Tarefa deletada com sucesso',
+    };
+  }
+
+  async getStats(userId: string) {
+    const { data, error } = await this.supabaseService
+      .getClient()
+      .from('tasks')
+      .select('completed')
+      .eq('user_id', userId);
+
+    if (error) {
+      throw new BadRequestException(`Erro ao obter estatísticas: ${error.message}`);
+    }
+
+    const total = data?.length || 0;
+    const completed = data?.filter((t) => t.completed)?.length || 0;
+    const pending = total - completed;
+
+    return {
+      success: true,
+      message: 'Estatísticas recuperadas com sucesso',
+      data: {
+        total,
+        completed,
+        pending,
+        completionPercentage: total > 0 ? Math.round((completed / total) * 100) : 0,
+      },
+    };
+  }
+}