Merge pull request #142 from Zindiks/claude/add-dashboard-analytics-01KKhDzpEF4cVjRvXB5U6kXB

feat: add comprehensive Dashboard & Analytics system

Author: Zindiks

api/src/bootstrap.ts

@@ -23,6 +23,10 @@ import assigneeRoutes from "./modules/assignees/assignee.route";
 import labelRoutes from "./modules/labels/label.route";
 import checklistRoutes from "./modules/checklists/checklist.route";
 import searchRoutes from "./modules/search/search.route";
+import analyticsRoutes from "./modules/analytics/analytics.route";
+import timeTrackingRoutes from "./modules/time-tracking/time-tracking.route";
+import sprintRoutes from "./modules/sprints/sprint.route";
+import reportRoutes from "./modules/reports/report.route";
 
 import { OrganizationSchema } from "./modules/organizations/organization.schema";
 import { BoardSchema } from "./modules/boards/board.schema";
@@ -35,6 +39,9 @@ import { AssigneeSchema } from "./modules/assignees/assignee.schema";
 import { LabelSchema } from "./modules/labels/label.schema";
 import { ChecklistSchema } from "./modules/checklists/checklist.schema";
 import { SearchSchema } from "./modules/search/search.schema";
+import { AnalyticsSchema } from "./modules/analytics/analytics.schema";
+import { TimeTrackingSchemas } from "./modules/time-tracking/time-tracking.schema";
+import { SprintSchemas } from "./modules/sprints/sprint.schema";
 
 import { swaggerDocs } from "./swagger";
 import { options } from "./configs/config";
@@ -94,6 +101,18 @@ async function addSchemas(server: FastifyInstance) {
   for (const schema of Object.values(SearchSchema)) {
     server.addSchema(schema);
   }
+
+  for (const schema of Object.values(AnalyticsSchema)) {
+    server.addSchema(schema);
+  }
+
+  for (const schema of Object.values(TimeTrackingSchemas)) {
+    server.addSchema(schema);
+  }
+
+  for (const schema of Object.values(SprintSchemas)) {
+    server.addSchema(schema);
+  }
 }
 
 async function registerRoutes(server: FastifyInstance) {
@@ -113,6 +132,10 @@ async function registerRoutes(server: FastifyInstance) {
           v1.register(labelRoutes, { prefix: "/labels" });
           v1.register(checklistRoutes, { prefix: "/checklists" });
           v1.register(searchRoutes, { prefix: "/search" });
+          v1.register(analyticsRoutes, { prefix: "/analytics" });
+          v1.register(timeTrackingRoutes, { prefix: "/time-tracking" });
+          v1.register(sprintRoutes, { prefix: "/sprints" });
+          v1.register(reportRoutes, { prefix: "/reports" });
         },
         { prefix: "/v1" },
       );

api/src/db/migrations/20251117100001_create_sprints_table.ts

@@ -0,0 +1,30 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  return knex.schema.createTable("sprints", function (table) {
+    table.uuid("id").primary().defaultTo(knex.raw("gen_random_uuid()"));
+    table
+      .uuid("board_id")
+      .notNullable()
+      .references("id")
+      .inTable("boards")
+      .onDelete("CASCADE");
+    table.string("name").notNullable();
+    table.text("goal").nullable();
+    table.timestamp("start_date").notNullable();
+    table.timestamp("end_date").notNullable();
+    table
+      .enum("status", ["planned", "active", "completed", "cancelled"])
+      .defaultTo("planned");
+    table.timestamp("created_at").defaultTo(knex.fn.now());
+    table.timestamp("updated_at").defaultTo(knex.fn.now());
+
+    // Indexes for performance
+    table.index("board_id");
+    table.index(["board_id", "status"]);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  return knex.schema.dropTable("sprints");
+}

api/src/db/migrations/20251117100002_create_time_logs_table.ts

@@ -0,0 +1,33 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  return knex.schema.createTable("time_logs", function (table) {
+    table.uuid("id").primary().defaultTo(knex.raw("gen_random_uuid()"));
+    table
+      .uuid("card_id")
+      .notNullable()
+      .references("id")
+      .inTable("cards")
+      .onDelete("CASCADE");
+    table
+      .uuid("user_id")
+      .notNullable()
+      .references("id")
+      .inTable("users")
+      .onDelete("CASCADE");
+    table.integer("duration_minutes").notNullable(); // Duration in minutes
+    table.text("description").nullable();
+    table.timestamp("logged_at").defaultTo(knex.fn.now());
+    table.timestamp("created_at").defaultTo(knex.fn.now());
+
+    // Indexes for performance
+    table.index("card_id");
+    table.index("user_id");
+    table.index("logged_at");
+    table.index(["card_id", "user_id"]);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  return knex.schema.dropTable("time_logs");
+}

api/src/db/migrations/20251117100003_add_sprint_id_to_cards.ts

@@ -0,0 +1,21 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  return knex.schema.alterTable("cards", function (table) {
+    table
+      .uuid("sprint_id")
+      .nullable()
+      .references("id")
+      .inTable("sprints")
+      .onDelete("SET NULL");
+
+    // Index for filtering cards by sprint
+    table.index("sprint_id");
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  return knex.schema.alterTable("cards", function (table) {
+    table.dropColumn("sprint_id");
+  });
+}

api/src/modules/analytics/analytics.controller.ts

@@ -0,0 +1,136 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import { AnalyticsService } from "./analytics.service";
+import {
+  PersonalDashboardQuery,
+  BoardAnalyticsParams,
+  SprintBurndownParams,
+} from "./analytics.schema";
+
+export class AnalyticsController {
+  constructor(private service: AnalyticsService) {}
+
+  /**
+   * GET /api/v1/analytics/dashboard/personal
+   * Get personal dashboard data
+   */
+  async getPersonalDashboard(
+    request: FastifyRequest<{
+      Querystring: PersonalDashboardQuery;
+    }>,
+    reply: FastifyReply
+  ) {
+    try {
+      const { organizationId } = request.query;
+      // @ts-ignore - user is added by auth middleware
+      const userId = request.user?.id;
+
+      if (!userId) {
+        return reply.code(401).send({ error: "Unauthorized" });
+      }
+
+      const dashboard = await this.service.getPersonalDashboard(
+        userId,
+        organizationId
+      );
+      return reply.code(200).send(dashboard);
+    } catch (error) {
+      request.log.error(error);
+      return reply.code(500).send({ error: "Internal server error" });
+    }
+  }
+
+  /**
+   * GET /api/v1/analytics/board/:boardId
+   * Get board analytics
+   */
+  async getBoardAnalytics(
+    request: FastifyRequest<{
+      Params: BoardAnalyticsParams;
+    }>,
+    reply: FastifyReply
+  ) {
+    try {
+      const { boardId } = request.params;
+      const analytics = await this.service.getBoardAnalytics(boardId);
+      return reply.code(200).send(analytics);
+    } catch (error) {
+      request.log.error(error);
+      return reply.code(500).send({ error: "Internal server error" });
+    }
+  }
+
+  /**
+   * GET /api/v1/analytics/sprint/:sprintId/burndown
+   * Get sprint burndown chart data
+   */
+  async getSprintBurndown(
+    request: FastifyRequest<{
+      Params: SprintBurndownParams;
+    }>,
+    reply: FastifyReply
+  ) {
+    try {
+      const { sprintId } = request.params;
+      const burndown = await this.service.getSprintBurndown(sprintId);
+
+      if (!burndown) {
+        return reply.code(404).send({ error: "Sprint not found" });
+      }
+
+      return reply.code(200).send(burndown);
+    } catch (error) {
+      request.log.error(error);
+      return reply.code(500).send({ error: "Internal server error" });
+    }
+  }
+
+  /**
+   * GET /api/v1/analytics/board/:boardId/velocity
+   * Get board velocity metrics
+   */
+  async getBoardVelocity(
+    request: FastifyRequest<{
+      Params: BoardAnalyticsParams;
+    }>,
+    reply: FastifyReply
+  ) {
+    try {
+      const { boardId } = request.params;
+      const velocity = await this.service.getBoardVelocity(boardId);
+      return reply.code(200).send(velocity);
+    } catch (error) {
+      request.log.error(error);
+      return reply.code(500).send({ error: "Internal server error" });
+    }
+  }
+
+  /**
+   * GET /api/v1/analytics/tasks/assigned
+   * Get user's assigned tasks
+   */
+  async getAssignedTasks(
+    request: FastifyRequest<{
+      Querystring: PersonalDashboardQuery;
+    }>,
+    reply: FastifyReply
+  ) {
+    try {
+      const { organizationId } = request.query;
+      // @ts-ignore - user is added by auth middleware
+      const userId = request.user?.id;
+
+      if (!userId) {
+        return reply.code(401).send({ error: "Unauthorized" });
+      }
+
+      const tasks = await this.service.getUserAssignedTasks(
+        userId,
+        organizationId
+      );
+      return reply.code(200).send(tasks);
+    } catch (error) {
+      request.log.error(error);
+      return reply.code(500).send({ error: "Internal server error" });
+    }
+  }
+}