Feat/implement milestones (#65)

* feat(db): create milestone entity and its relations

* feat: implements get milestones route

* feat: implements create milestone module

* feat: implements update milestone modules

* feat: implements get unique milestone modules

* feat: implements delete milestone modules

* refactor: fix typo in variable name

* feat: implements module to return all tasks in a milestone

* feat: implements assign tasks to milestone module

* feat: implements progress on milestone modules

* fix(milestones): ensure task association consistency and cleanup on deletion

* feat(tasks): implement two-way consistency for labels and milestones

* feat(milestones): implements validation in end date to be equal or after start
date

* fix(provider): adjust to make dark mode as default theme

* fix: address feedback for milestone and task management

Author: MatheusFilg

apps/server/src/modules/labels/delete-label/use-case.ts

@@ -1,7 +1,31 @@
 import { prisma } from "@blaboard/db";
 
 export async function deleteLabelUseCase(id: string, organizationId: string) {
-	return await prisma.label.delete({
+	const label = await prisma.label.delete({
 		where: { id, organizationId },
 	});
+
+	if (label.taskIds && label.taskIds.length > 0) {
+		for (const taskId of label.taskIds) {
+			const task = await prisma.task.findUnique({
+				where: { id: taskId, organizationId },
+				select: {
+					labelIds: true,
+				},
+			});
+
+			if (task) {
+				await prisma.task.update({
+					where: { id: taskId },
+					data: {
+						labelIds: {
+							set: task.labelIds.filter((lid) => lid !== id),
+						},
+					},
+				});
+			}
+		}
+	}
+
+	return label;
 }

apps/server/src/modules/milestones/assign-tasks-milestone/router.ts

@@ -0,0 +1,32 @@
+import { Elysia } from "elysia";
+import { authMiddleware } from "@/shared/http/middleware/auth.middleware";
+import { authMiddlewareErrorSchemas } from "@/shared/schemas/auth-middleware-errors";
+import {
+	assignTasksMilestoneBodySchema,
+	assignTasksMilestoneParamsSchema,
+	assignTasksMilestoneResponseSchema,
+} from "./schemas";
+import { assignTasksMilestone } from "./use-case";
+
+export const assignTasksMilestoneRouter = new Elysia()
+	.use(authMiddleware)
+	.patch(
+		":id/tasks",
+		async ({ status, params, session, body }) => {
+			const result = await assignTasksMilestone(
+				params.id,
+				session.activeOrganizationId,
+				body,
+			);
+			return status(200, result);
+		},
+		{
+			requireOrganization: true,
+			body: assignTasksMilestoneBodySchema,
+			params: assignTasksMilestoneParamsSchema,
+			response: {
+				200: assignTasksMilestoneResponseSchema,
+				...authMiddlewareErrorSchemas,
+			},
+		},
+	);

apps/server/src/modules/milestones/assign-tasks-milestone/schemas.ts

@@ -0,0 +1,28 @@
+import z from "zod";
+import { milestonesStatusSchema } from "@/shared/schemas/milestone-status";
+import { zDate } from "@/shared/schemas/zod-date";
+
+export const assignTasksMilestoneParamsSchema = z.object({
+	id: z.string().min(1),
+});
+
+export const assignTasksMilestoneBodySchema = z.object({
+	taskIds: z.array(z.string()).min(1),
+});
+
+export type AssignTasksMilestoneBody = z.infer<
+	typeof assignTasksMilestoneBodySchema
+>;
+
+export const assignTasksMilestoneResponseSchema = z.object({
+	id: z.string(),
+	description: z.string().nullable(),
+	organizationId: z.string(),
+	createdAt: zDate,
+	updatedAt: zDate,
+	taskIds: z.array(z.string()),
+	name: z.string(),
+	status: milestonesStatusSchema,
+	startDate: zDate.nullable(),
+	endDate: zDate.nullable(),
+});

apps/server/src/modules/milestones/assign-tasks-milestone/use-case.ts

@@ -0,0 +1,69 @@
+import { prisma } from "@blaboard/db";
+import type { AssignTasksMilestoneBody } from "./schemas";
+
+export async function assignTasksMilestone(
+	milestoneId: string,
+	organizationId: string,
+	input: AssignTasksMilestoneBody,
+) {
+	return await prisma.$transaction(async (tx) => {
+		const taskWithMilestone = await tx.task.findMany({
+			where: {
+				id: { in: input.taskIds },
+				organizationId,
+				milestoneId: { not: null, notIn: [milestoneId] },
+			},
+			select: {
+				id: true,
+				milestoneId: true,
+			},
+		});
+
+		for (const task of taskWithMilestone) {
+			if (task.milestoneId) {
+				const oldMilestone = await tx.milestone.findUnique({
+					where: { id: task.milestoneId },
+				});
+
+				if (oldMilestone) {
+					await tx.milestone.update({
+						where: { id: task.milestoneId },
+						data: {
+							taskIds: {
+								set: oldMilestone.taskIds.filter((tid) => tid !== task.id),
+							},
+						},
+					});
+				}
+			}
+		}
+
+		await tx.task.updateMany({
+			where: {
+				id: { in: input.taskIds },
+				organizationId,
+			},
+			data: {
+				milestoneId: milestoneId,
+			},
+		});
+
+		const currentMilestone = await tx.milestone.findUnique({
+			where: { id: milestoneId },
+		});
+
+		const uniqueTaskIds = Array.from(
+			new Set([...(currentMilestone?.taskIds || []), ...input.taskIds]),
+		);
+
+		return await tx.milestone.update({
+			where: {
+				id: milestoneId,
+				organizationId,
+			},
+			data: {
+				taskIds: { set: uniqueTaskIds },
+			},
+		});
+	});
+}

apps/server/src/modules/milestones/create-milestone/router.ts

@@ -0,0 +1,24 @@
+import { Elysia } from "elysia";
+import { authMiddleware } from "@/shared/http/middleware/auth.middleware";
+import { authMiddlewareErrorSchemas } from "@/shared/schemas/auth-middleware-errors";
+import {
+	createMilestonesBodySchema,
+	createMilestonesResponseSchema,
+} from "./schemas";
+import { createMilestone } from "./use-case";
+
+export const createMilestoneRouter = new Elysia().use(authMiddleware).post(
+	"/",
+	async ({ status, session, body }) => {
+		const result = await createMilestone(session.activeOrganizationId, body);
+		return status(201, result);
+	},
+	{
+		requireOrganization: true,
+		body: createMilestonesBodySchema,
+		response: {
+			201: createMilestonesResponseSchema,
+			...authMiddlewareErrorSchemas,
+		},
+	},
+);

apps/server/src/modules/milestones/create-milestone/schemas.ts

@@ -0,0 +1,41 @@
+import z from "zod";
+import { milestonesStatusSchema } from "@/shared/schemas/milestone-status";
+import { zDate } from "@/shared/schemas/zod-date";
+
+export const createMilestonesBodySchema = z
+	.object({
+		name: z.string().min(2).max(100),
+		description: z.string().min(2).max(200).nullable(),
+		status: milestonesStatusSchema,
+		startDate: zDate.nullable(),
+		endDate: zDate.nullable(),
+	})
+	.refine(
+		(data) => {
+			if (data.startDate && data.endDate) {
+				const start = new Date(data.startDate);
+				const end = new Date(data.endDate);
+				return end >= start;
+			}
+			return true;
+		},
+		{
+			message: "End date must be after or equal to start date",
+			path: ["endDate"],
+		},
+	);
+
+export type CreateMilestonesInput = z.infer<typeof createMilestonesBodySchema>;
+
+export const createMilestonesResponseSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	status: milestonesStatusSchema,
+	startDate: zDate.nullable(),
+	endDate: zDate.nullable(),
+	organizationId: z.string(),
+	taskIds: z.array(z.string()),
+	createdAt: zDate,
+	updatedAt: zDate,
+});

apps/server/src/modules/milestones/create-milestone/use-case.ts

@@ -0,0 +1,18 @@
+import { prisma } from "@blaboard/db";
+import type { CreateMilestonesInput } from "./schemas";
+
+export async function createMilestone(
+	organizationId: string,
+	input: CreateMilestonesInput,
+) {
+	return prisma.milestone.create({
+		data: {
+			name: input.name,
+			description: input.description,
+			status: input.status,
+			startDate: input.startDate,
+			endDate: input.endDate,
+			organizationId,
+		},
+	});
+}

apps/server/src/modules/milestones/delete-milestone/router.ts

@@ -0,0 +1,28 @@
+import { Elysia } from "elysia";
+import { authMiddleware } from "@/shared/http/middleware/auth.middleware";
+import { authMiddlewareErrorSchemas } from "@/shared/schemas/auth-middleware-errors";
+import {
+	deleteMilestoneParamsSchema,
+	deleteMilestoneResponseSchema,
+} from "./schemas";
+import { deleteMilestone } from "./use-case";
+
+export const deleteMilestonesRouter = new Elysia().use(authMiddleware).delete(
+	"/:id",
+	async ({ session, params, status }) => {
+		const result = await deleteMilestone(
+			params.id,
+			session.activeOrganizationId,
+		);
+
+		return status(200, result);
+	},
+	{
+		requireOrganization: true,
+		params: deleteMilestoneParamsSchema,
+		response: {
+			200: deleteMilestoneResponseSchema,
+			...authMiddlewareErrorSchemas,
+		},
+	},
+);

apps/server/src/modules/milestones/delete-milestone/schemas.ts

@@ -0,0 +1,20 @@
+import z from "zod";
+import { milestonesStatusSchema } from "@/shared/schemas/milestone-status";
+import { zDate } from "@/shared/schemas/zod-date";
+
+export const deleteMilestoneParamsSchema = z.object({
+	id: z.string().min(2),
+});
+
+export const deleteMilestoneResponseSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	status: milestonesStatusSchema,
+	startDate: zDate.nullable(),
+	endDate: zDate.nullable(),
+	taskIds: z.array(z.string()),
+	organizationId: z.string(),
+	createdAt: zDate,
+	updatedAt: zDate,
+});

apps/server/src/modules/milestones/delete-milestone/use-case.ts

@@ -0,0 +1,11 @@
+import { prisma } from "@blaboard/db";
+
+export async function deleteMilestone(id: string, organizationId: string) {
+	return await prisma.$transaction(async (tx) => {
+		await tx.task.updateMany({
+			where: { milestoneId: id, organizationId },
+			data: { milestoneId: null },
+		});
+		return await tx.milestone.delete({ where: { id, organizationId } });
+	});
+}