feat: add contributors page gf-250

apps/backend/src/libs/modules/server-application/server-application.ts

@@ -3,6 +3,7 @@ import { database } from "~/libs/modules/database/database.js";
 import { logger } from "~/libs/modules/logger/logger.js";
 import { activityLogController } from "~/modules/activity-logs/activity-logs.js";
 import { authController } from "~/modules/auth/auth.js";
+import { contributorController } from "~/modules/contributors/contributors.js";
 import { groupController } from "~/modules/groups/groups.js";
 import { permissionController } from "~/modules/permissions/permissions.js";
 import { projectApiKeyController } from "~/modules/project-api-keys/project-api-keys.js";
@@ -23,6 +24,7 @@ const apiV1 = new BaseServerApplicationApi(
 	...permissionController.routes,
 	...projectGroupController.routes,
 	...projectController.routes,
+	...contributorController.routes,
 	...userController.routes,
 	...groupController.routes,
 	...projectApiKeyController.routes,

apps/backend/src/modules/contributors/contributor.controller.ts

@@ -0,0 +1,86 @@
+import { APIPath } from "~/libs/enums/enums.js";
+import {
+	type APIHandlerResponse,
+	BaseController,
+} from "~/libs/modules/controller/controller.js";
+import { HTTPCode } from "~/libs/modules/http/http.js";
+import { type Logger } from "~/libs/modules/logger/logger.js";
+
+import { type ContributorService } from "./contributor.service.js";
+import { ContributorsApiPath } from "./libs/enums/enums.js";
+
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     Contributor:
+ *       type: object
+ *       properties:
+ *         id:
+ *           type: number
+ *           minimum: 1
+ *         name:
+ *           type: string
+ *         gitEmails:
+ *           type: array
+ *           items:
+ *             type: object
+ *             properties:
+ *               id:
+ *                 type: number
+ *                 minimum: 1
+ *               email:
+ *                 type: string
+ *         projects:
+ *           type: array
+ *           items:
+ *             type: object
+ *             properties:
+ *               id:
+ *                 type: number
+ *                 minimum: 1
+ *               name:
+ *                 type: string
+ */
+class ContributorController extends BaseController {
+	private contributorService: ContributorService;
+
+	public constructor(logger: Logger, contributorService: ContributorService) {
+		super(logger, APIPath.CONTRIBUTORS);
+
+		this.contributorService = contributorService;
+
+		this.addRoute({
+			handler: () => this.findAll(),
+			method: "GET",
+			path: ContributorsApiPath.ROOT,
+		});
+	}
+
+	/**
+	 * @swagger
+	 * /contributors:
+	 *   get:
+	 *     description: Returns an array of contributors
+	 *     responses:
+	 *       200:
+	 *         description: Successful operation
+	 *         content:
+	 *           application/json:
+	 *             schema:
+	 *               type: object
+	 *               properties:
+	 *                 items:
+	 *                   type: array
+	 *                   items:
+	 *                     $ref: "#/components/schemas/Contributor"
+	 */
+	private async findAll(): Promise<APIHandlerResponse> {
+		return {
+			payload: await this.contributorService.findAll(),
+			status: HTTPCode.OK,
+		};
+	}
+}
+
+export { ContributorController };

apps/backend/src/modules/contributors/contributor.entity.ts

@@ -3,47 +3,82 @@ import { type Entity } from "~/libs/types/types.js";
 import { type ContributorGetAllItemResponseDto } from "./libs/types/types.js";
 
 class ContributorEntity implements Entity {
+	private gitEmails: { email: string; id: number }[];
 	private id: null | number;
-
 	private name: string;
+	private projects: { id: number; name: string }[];
 
-	private constructor({ id, name }: { id: null | number; name: string }) {
+	private constructor({
+		gitEmails,
+		id,
+		name,
+		projects,
+	}: {
+		gitEmails: { email: string; id: number }[];
+		id: null | number;
+		name: string;
+		projects: { id: number; name: string }[];
+	}) {
 		this.id = id;
 		this.name = name;
+		this.gitEmails = gitEmails;
+		this.projects = projects;
 	}
 
 	public static initialize({
+		gitEmails,
 		id,
 		name,
+		projects,
 	}: {
+		gitEmails: { email: string; id: number }[];
 		id: number;
 		name: string;
+		projects: { id: number; name: string }[];
 	}): ContributorEntity {
 		return new ContributorEntity({
+			gitEmails,
 			id,
 			name,
+			projects,
 		});
 	}
 
-	public static initializeNew({ name }: { name: string }): ContributorEntity {
+	public static initializeNew({
+		gitEmails = [],
+		name,
+		projects = [],
+	}: {
+		gitEmails?: { email: string; id: number }[];
+		name: string;
+		projects?: { id: number; name: string }[];
+	}): ContributorEntity {
 		return new ContributorEntity({
+			gitEmails,
 			id: null,
 			name,
+			projects,
 		});
 	}
 
 	public toNewObject(): {
+		gitEmails: { email: string; id: number }[];
 		name: string;
+		projects: { id: number; name: string }[];
 	} {
 		return {
+			gitEmails: this.gitEmails,
 			name: this.name,
+			projects: this.projects,
 		};
 	}
 
 	public toObject(): ContributorGetAllItemResponseDto {
 		return {
+			gitEmails: this.gitEmails,
 			id: this.id as number,
 			name: this.name,
+			projects: this.projects,
 		};
 	}
 }

apps/backend/src/modules/contributors/contributor.model.ts

@@ -7,6 +7,7 @@ import {
 import { GitEmailModel } from "~/modules/git-emails/git-emails.js";
 
 class ContributorModel extends AbstractModel {
+	public gitEmails!: GitEmailModel[];
 	public name!: string;
 
 	public static override get relationMappings(): RelationMappings {

apps/backend/src/modules/contributors/contributor.repository.ts

@@ -15,35 +15,52 @@ class ContributorRepository implements Repository {
 
 		const contributor = await this.contributorModel
 			.query()
-			.insert({
-				name,
-			})
+			.insert({ name })
 			.execute();
 
-		return ContributorEntity.initialize(contributor);
+		return ContributorEntity.initialize({ ...contributor, projects: [] });
 	}
 
 	public delete(): ReturnType<Repository["delete"]> {
 		return Promise.resolve(true);
 	}
 
 	public async find(id: number): Promise<ContributorEntity | null> {
-		const item = await this.contributorModel.query().findById(id).execute();
+		const contributor = await this.contributorModel
+			.query()
+			.findById(id)
+			.withGraphFetched("gitEmails");
 
-		return item ? ContributorEntity.initialize(item) : null;
+		if (!contributor) {
+			return null;
+		}
+
+		return ContributorEntity.initialize({ ...contributor, projects: [] });
 	}
 
-	public findAll(): ReturnType<Repository["findAll"]> {
-		return Promise.resolve({ items: [] });
+	public async findAll(): Promise<{ items: ContributorEntity[] }> {
+		const contributors = await this.contributorModel
+			.query()
+			.withGraphFetched("gitEmails");
+
+		return {
+			items: contributors.map((contributor) =>
+				ContributorEntity.initialize({ ...contributor, projects: [] }),
+			),
+		};
 	}
 
 	public async findByName(name: string): Promise<ContributorEntity | null> {
-		const item = await this.contributorModel
+		const contributor = await this.contributorModel
 			.query()
 			.findOne({ name })
-			.execute();
+			.withGraphFetched("gitEmails");
+
+		if (!contributor) {
+			return null;
+		}
 
-		return item ? ContributorEntity.initialize(item) : null;
+		return ContributorEntity.initialize({ ...contributor, projects: [] });
 	}
 
 	public update(): ReturnType<Repository["update"]> {

apps/backend/src/modules/contributors/contributors.service.ts → apps/backend/src/modules/contributors/contributor.service.ts

@@ -2,19 +2,26 @@ import { ExceptionMessage } from "~/libs/enums/enums.js";
 import { HTTPCode } from "~/libs/modules/http/http.js";
 import { type Service } from "~/libs/types/types.js";
 
+import { type ProjectService } from "../projects/project.service.js";
 import { ContributorEntity } from "./contributor.entity.js";
 import { type ContributorRepository } from "./contributor.repository.js";
 import { ContributorError } from "./libs/exceptions/exceptions.js";
 import {
 	type ContributorCreateRequestDto,
 	type ContributorGetAllItemResponseDto,
+	type ContributorGetAllResponseDto,
 } from "./libs/types/types.js";
 
 class ContributorService implements Service {
 	private contributorRepository: ContributorRepository;
+	private projectService: ProjectService;
 
-	public constructor(contributorRepository: ContributorRepository) {
+	public constructor(
+		contributorRepository: ContributorRepository,
+		projectService: ProjectService,
+	) {
 		this.contributorRepository = contributorRepository;
+		this.projectService = projectService;
 	}
 
 	public async create(
@@ -45,19 +52,53 @@ class ContributorService implements Service {
 			});
 		}
 
-		return item.toObject();
+		const projects = await this.projectService.findProjectsByContributorId(id);
+
+		return { ...item.toObject(), projects: projects.items };
 	}
 
-	public findAll(): ReturnType<Service["findAll"]> {
-		return Promise.resolve({ items: [] });
+	public async findAll(): Promise<ContributorGetAllResponseDto> {
+		const contributors = await this.contributorRepository.findAll();
+
+		const contributorsWithProjects = await Promise.all(
+			contributors.items.map(async (item) => {
+				const contributor = item.toObject();
+
+				const projects = await this.projectService.findProjectsByContributorId(
+					contributor.id,
+				);
+
+				return {
+					...contributor,
+					gitEmails: contributor.gitEmails.map((gitEmail) => ({
+						email: gitEmail.email,
+						id: gitEmail.id,
+					})),
+					projects: projects.items.map((project) => ({
+						id: project.id,
+						name: project.name,
+					})),
+				};
+			}),
+		);
+
+		return { items: contributorsWithProjects };
 	}
 
 	public async findByName(
 		name: string,
 	): Promise<ContributorGetAllItemResponseDto | null> {
 		const item = await this.contributorRepository.findByName(name);
 
-		return item ? item.toObject() : null;
+		if (!item) {
+			return null;
+		}
+
+		const projects = await this.projectService.findProjectsByContributorId(
+			item.toObject().id,
+		);
+
+		return { ...item.toObject(), projects: projects.items };
 	}
 
 	public update(): ReturnType<Service["update"]> {

apps/backend/src/modules/contributors/contributors.ts

@@ -1,11 +1,21 @@
+import { logger } from "~/libs/modules/logger/logger.js";
+
+import { projectService } from "../projects/projects.js";
+import { ContributorController } from "./contributor.controller.js";
 import { ContributorModel } from "./contributor.model.js";
 import { ContributorRepository } from "./contributor.repository.js";
-import { ContributorService } from "./contributors.service.js";
+import { ContributorService } from "./contributor.service.js";
 
 const contributorRepository = new ContributorRepository(ContributorModel);
-const contributorService = new ContributorService(contributorRepository);
+const contributorService = new ContributorService(
+	contributorRepository,
+	projectService,
+);
+const contributorController = new ContributorController(
+	logger,
+	contributorService,
+);
 
 export { ContributorModel } from "./contributor.model.js";
-export { ContributorRepository } from "./contributor.repository.js";
-export { ContributorService } from "./contributors.service.js";
-export { contributorService };
+export { ContributorService } from "./contributor.service.js";
+export { contributorController, contributorService };

apps/backend/src/modules/contributors/libs/enums/enums.ts

@@ -0,0 +1 @@
+export { ContributorsApiPath } from "@git-fit/shared";

apps/backend/src/modules/projects/project.repository.ts

@@ -75,6 +75,22 @@ class ProjectRepository implements Repository {
 		return item ? ProjectEntity.initialize(item) : null;
 	}
 
+	public async findProjectsByContributorId(
+		contributorId: number,
+	): Promise<{ items: ProjectEntity[] }> {
+		const projects = await this.projectModel
+			.query()
+			.select("projects.*")
+			.join("activity_logs", "activity_logs.project_id", "projects.id")
+			.join("git_emails", "git_emails.id", "activity_logs.git_email_id")
+			.where("git_emails.contributor_id", contributorId)
+			.distinct();
+
+		return {
+			items: projects.map((project) => ProjectEntity.initialize(project)),
+		};
+	}
+
 	public async patch(
 		id: number,
 		projectData: ProjectPatchRequestDto,