feat(#5): Implement CRUD APIs for tasks, events, and projects

Implements comprehensive CRUD APIs following TDD principles with 92.44%
test coverage (exceeds 85% requirement).

Features:
- Tasks API: Full CRUD with filtering, pagination, and subtask support
- Events API: Full CRUD with recurrence support and date filtering
- Projects API: Full CRUD with task/event association
- Authentication guards on all endpoints
- Workspace-scoped queries for multi-tenant isolation
- Activity logging for all operations (CREATED, UPDATED, DELETED, etc.)
- DTOs with class-validator validation
- Comprehensive test suite (221 tests, 44 for new APIs)

Implementation:
- Services: Business logic with Prisma ORM integration
- Controllers: RESTful endpoints with AuthGuard
- Modules: Properly registered in AppModule
- Documentation: Complete API reference in docs/4-api/4-crud-endpoints/

Test Coverage:
- Tasks: 96.1%
- Events: 89.83%
- Projects: 84.21%
- Overall: 92.44%

TDD Workflow:
1. RED: Wrote failing tests first
2. GREEN: Implemented minimal code to pass tests
3. REFACTOR: Improved code quality while maintaining coverage

Refs #5

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

apps/api/src/tasks/tasks.controller.spec.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { TasksController } from "./tasks.controller";
+import { TasksService } from "./tasks.service";
+import { TaskStatus, TaskPriority } from "@prisma/client";
+import { AuthGuard } from "../auth/guards/auth.guard";
+import { ExecutionContext } from "@nestjs/common";
+
+describe("TasksController", () => {
+  let controller: TasksController;
+  let service: TasksService;
+
+  const mockTasksService = {
+    create: vi.fn(),
+    findAll: vi.fn(),
+    findOne: vi.fn(),
+    update: vi.fn(),
+    remove: vi.fn(),
+  };
+
+  const mockAuthGuard = {
+    canActivate: vi.fn((context: ExecutionContext) => {
+      const request = context.switchToHttp().getRequest();
+      request.user = {
+        id: "550e8400-e29b-41d4-a716-446655440002",
+        workspaceId: "550e8400-e29b-41d4-a716-446655440001",
+      };
+      return true;
+    }),
+  };
+
+  const mockWorkspaceId = "550e8400-e29b-41d4-a716-446655440001";
+  const mockUserId = "550e8400-e29b-41d4-a716-446655440002";
+  const mockTaskId = "550e8400-e29b-41d4-a716-446655440003";
+
+  const mockRequest = {
+    user: {
+      id: mockUserId,
+      workspaceId: mockWorkspaceId,
+    },
+  };
+
+  const mockTask = {
+    id: mockTaskId,
+    workspaceId: mockWorkspaceId,
+    title: "Test Task",
+    description: "Test Description",
+    status: TaskStatus.NOT_STARTED,
+    priority: TaskPriority.MEDIUM,
+    dueDate: new Date("2026-02-01T12:00:00Z"),
+    assigneeId: null,
+    creatorId: mockUserId,
+    projectId: null,
+    parentId: null,
+    sortOrder: 0,
+    metadata: {},
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    completedAt: null,
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [TasksController],
+      providers: [
+        {
+          provide: TasksService,
+          useValue: mockTasksService,
+        },
+      ],
+    })
+      .overrideGuard(AuthGuard)
+      .useValue(mockAuthGuard)
+      .compile();
+
+    controller = module.get<TasksController>(TasksController);
+    service = module.get<TasksService>(TasksService);
+
+    vi.clearAllMocks();
+  });
+
+  it("should be defined", () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe("create", () => {
+    it("should create a task", async () => {
+      const createDto = {
+        title: "New Task",
+        description: "Task description",
+      };
+
+      mockTasksService.create.mockResolvedValue(mockTask);
+
+      const result = await controller.create(createDto, mockRequest);
+
+      expect(result).toEqual(mockTask);
+      expect(service.create).toHaveBeenCalledWith(
+        mockWorkspaceId,
+        mockUserId,
+        createDto
+      );
+    });
+  });
+
+  describe("findAll", () => {
+    it("should return paginated tasks", async () => {
+      const query = {
+        workspaceId: mockWorkspaceId,
+        page: 1,
+        limit: 50,
+      };
+
+      const paginatedResult = {
+        data: [mockTask],
+        meta: {
+          total: 1,
+          page: 1,
+          limit: 50,
+          totalPages: 1,
+        },
+      };
+
+      mockTasksService.findAll.mockResolvedValue(paginatedResult);
+
+      const result = await controller.findAll(query, mockRequest);
+
+      expect(result).toEqual(paginatedResult);
+      expect(service.findAll).toHaveBeenCalledWith({
+        ...query,
+        workspaceId: mockWorkspaceId,
+      });
+    });
+
+    it("should extract workspaceId from request.user if not in query", async () => {
+      const query = {};
+
+      mockTasksService.findAll.mockResolvedValue({
+        data: [],
+        meta: { total: 0, page: 1, limit: 50, totalPages: 0 },
+      });
+
+      await controller.findAll(query as any, mockRequest);
+
+      expect(service.findAll).toHaveBeenCalledWith(
+        expect.objectContaining({
+          workspaceId: mockWorkspaceId,
+        })
+      );
+    });
+  });
+
+  describe("findOne", () => {
+    it("should return a task by id", async () => {
+      mockTasksService.findOne.mockResolvedValue(mockTask);
+
+      const result = await controller.findOne(mockTaskId, mockRequest);
+
+      expect(result).toEqual(mockTask);
+      expect(service.findOne).toHaveBeenCalledWith(mockTaskId, mockWorkspaceId);
+    });
+
+    it("should throw error if workspaceId not found", async () => {
+      const requestWithoutWorkspace = {
+        user: { id: mockUserId },
+      };
+
+      await expect(
+        controller.findOne(mockTaskId, requestWithoutWorkspace)
+      ).rejects.toThrow("User workspaceId not found");
+    });
+  });
+
+  describe("update", () => {
+    it("should update a task", async () => {
+      const updateDto = {
+        title: "Updated Task",
+        status: TaskStatus.IN_PROGRESS,
+      };
+
+      const updatedTask = { ...mockTask, ...updateDto };
+      mockTasksService.update.mockResolvedValue(updatedTask);
+
+      const result = await controller.update(mockTaskId, updateDto, mockRequest);
+
+      expect(result).toEqual(updatedTask);
+      expect(service.update).toHaveBeenCalledWith(
+        mockTaskId,
+        mockWorkspaceId,
+        mockUserId,
+        updateDto
+      );
+    });
+
+    it("should throw error if workspaceId not found", async () => {
+      const requestWithoutWorkspace = {
+        user: { id: mockUserId },
+      };
+
+      await expect(
+        controller.update(mockTaskId, { title: "Test" }, requestWithoutWorkspace)
+      ).rejects.toThrow("User workspaceId not found");
+    });
+  });
+
+  describe("remove", () => {
+    it("should delete a task", async () => {
+      mockTasksService.remove.mockResolvedValue(undefined);
+
+      await controller.remove(mockTaskId, mockRequest);
+
+      expect(service.remove).toHaveBeenCalledWith(
+        mockTaskId,
+        mockWorkspaceId,
+        mockUserId
+      );
+    });
+
+    it("should throw error if workspaceId not found", async () => {
+      const requestWithoutWorkspace = {
+        user: { id: mockUserId },
+      };
+
+      await expect(
+        controller.remove(mockTaskId, requestWithoutWorkspace)
+      ).rejects.toThrow("User workspaceId not found");
+    });
+  });
+});