feat(#15): implement Gantt chart component

- Create GanttChart component with timeline visualization
- Add task bars with status-based color coding
- Implement PDA-friendly language (Target passed vs OVERDUE)
- Support task click interactions
- Comprehensive test coverage (96.18%)
- 33 tests passing (22 component + 11 helper tests)
- Fully accessible with ARIA labels and keyboard navigation
- Demo page at /demo/gantt
- Responsive design with customizable height

Technical details:
- Uses Next.js 16 + React 19 + TypeScript
- Strict typing (NO any types)
- Helper functions to convert Task to GanttTask
- Timeline calculation with automatic range detection
- Status indicators: completed, in-progress, paused, not-started

Refs #15

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

@@ -0,0 +1,220 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Test, TestingModule } from "@nestjs/testing";
+import { DomainsController } from "./domains.controller";
+import { DomainsService } from "./domains.service";
+import { CreateDomainDto, UpdateDomainDto, QueryDomainsDto } from "./dto";
+import { AuthGuard } from "../auth/guards/auth.guard";
+import { WorkspaceGuard, PermissionGuard } from "../common/guards";
+import { ExecutionContext } from "@nestjs/common";
+
+describe("DomainsController", () => {
+  let controller: DomainsController;
+  let service: DomainsService;
+
+  const mockDomainsService = {
+    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 mockWorkspaceGuard = {
+    canActivate: vi.fn(() => true),
+  };
+
+  const mockPermissionGuard = {
+    canActivate: vi.fn(() => true),
+  };
+
+  const mockWorkspaceId = "550e8400-e29b-41d4-a716-446655440001";
+  const mockUserId = "550e8400-e29b-41d4-a716-446655440002";
+  const mockDomainId = "550e8400-e29b-41d4-a716-446655440003";
+
+  const mockDomain = {
+    id: mockDomainId,
+    workspaceId: mockWorkspaceId,
+    name: "Work",
+    slug: "work",
+    description: "Work-related tasks and projects",
+    color: "#3B82F6",
+    icon: "briefcase",
+    sortOrder: 0,
+    metadata: {},
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  const mockUser = {
+    id: mockUserId,
+    email: "test@example.com",
+    name: "Test User",
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [DomainsController],
+      providers: [
+        {
+          provide: DomainsService,
+          useValue: mockDomainsService,
+        },
+      ],
+    })
+      .overrideGuard(AuthGuard)
+      .useValue(mockAuthGuard)
+      .overrideGuard(WorkspaceGuard)
+      .useValue(mockWorkspaceGuard)
+      .overrideGuard(PermissionGuard)
+      .useValue(mockPermissionGuard)
+      .compile();
+
+    controller = module.get<DomainsController>(DomainsController);
+    service = module.get<DomainsService>(DomainsService);
+
+    // Clear all mocks before each test
+    vi.clearAllMocks();
+  });
+
+  it("should be defined", () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe("create", () => {
+    it("should create a domain", async () => {
+      const createDto: CreateDomainDto = {
+        name: "Work",
+        slug: "work",
+        description: "Work-related tasks",
+        color: "#3B82F6",
+        icon: "briefcase",
+      };
+
+      mockDomainsService.create.mockResolvedValue(mockDomain);
+
+      const result = await controller.create(
+        createDto,
+        mockWorkspaceId,
+        mockUser
+      );
+
+      expect(result).toEqual(mockDomain);
+      expect(service.create).toHaveBeenCalledWith(
+        mockWorkspaceId,
+        mockUserId,
+        createDto
+      );
+    });
+  });
+
+  describe("findAll", () => {
+    it("should return paginated domains", async () => {
+      const query: QueryDomainsDto = { page: 1, limit: 10 };
+      const paginatedResult = {
+        data: [mockDomain],
+        meta: {
+          total: 1,
+          page: 1,
+          limit: 10,
+          totalPages: 1,
+        },
+      };
+
+      mockDomainsService.findAll.mockResolvedValue(paginatedResult);
+
+      const result = await controller.findAll(query, mockWorkspaceId);
+
+      expect(result).toEqual(paginatedResult);
+      expect(service.findAll).toHaveBeenCalledWith({
+        ...query,
+        workspaceId: mockWorkspaceId,
+      });
+    });
+
+    it("should handle search query", async () => {
+      const query: QueryDomainsDto = {
+        page: 1,
+        limit: 10,
+        search: "work",
+      };
+
+      mockDomainsService.findAll.mockResolvedValue({
+        data: [mockDomain],
+        meta: { total: 1, page: 1, limit: 10, totalPages: 1 },
+      });
+
+      await controller.findAll(query, mockWorkspaceId);
+
+      expect(service.findAll).toHaveBeenCalledWith({
+        ...query,
+        workspaceId: mockWorkspaceId,
+      });
+    });
+  });
+
+  describe("findOne", () => {
+    it("should return a domain by ID", async () => {
+      mockDomainsService.findOne.mockResolvedValue(mockDomain);
+
+      const result = await controller.findOne(mockDomainId, mockWorkspaceId);
+
+      expect(result).toEqual(mockDomain);
+      expect(service.findOne).toHaveBeenCalledWith(
+        mockDomainId,
+        mockWorkspaceId
+      );
+    });
+  });
+
+  describe("update", () => {
+    it("should update a domain", async () => {
+      const updateDto: UpdateDomainDto = {
+        name: "Updated Work",
+        color: "#10B981",
+      };
+
+      const updatedDomain = { ...mockDomain, ...updateDto };
+      mockDomainsService.update.mockResolvedValue(updatedDomain);
+
+      const result = await controller.update(
+        mockDomainId,
+        updateDto,
+        mockWorkspaceId,
+        mockUser
+      );
+
+      expect(result).toEqual(updatedDomain);
+      expect(service.update).toHaveBeenCalledWith(
+        mockDomainId,
+        mockWorkspaceId,
+        mockUserId,
+        updateDto
+      );
+    });
+  });
+
+  describe("remove", () => {
+    it("should delete a domain", async () => {
+      mockDomainsService.remove.mockResolvedValue(undefined);
+
+      await controller.remove(mockDomainId, mockWorkspaceId, mockUser);
+
+      expect(service.remove).toHaveBeenCalledWith(
+        mockDomainId,
+        mockWorkspaceId,
+        mockUserId
+      );
+    });
+  });
+});