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";
@@ -25,6 +26,7 @@ const apiV1 = new BaseServerApplicationApi(
 	...projectGroupController.routes,
 	...projectPermissionsController.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

@@ -6,8 +6,12 @@ import {
 } from "~/libs/modules/database/database.js";
 import { GitEmailModel } from "~/modules/git-emails/git-emails.js";
 
+import { type ProjectModel } from "../projects/project.model.js";
+
 class ContributorModel extends AbstractModel {
+	public gitEmails!: GitEmailModel[];
 	public name!: string;
+	public projects!: ProjectModel[];
 
 	public static override get relationMappings(): RelationMappings {
 		return {

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

@@ -1,3 +1,5 @@
+import { raw } from "objection";
+
 import { type Repository } from "~/libs/types/types.js";
 
 import { ContributorEntity } from "./contributor.entity.js";
@@ -15,35 +17,68 @@ 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 contributorsWithProjectsAndEmails = await this.contributorModel
+			.query()
+			.select("contributors.*")
+			.select(
+				raw(
+					"COALESCE(ARRAY_AGG(DISTINCT jsonb_build_object('id', projects.id, 'name', projects.name)) FILTER (WHERE projects.id IS NOT NULL), '{}') AS projects",
+				),
+			)
+			.select(
+				raw(
+					"COALESCE(ARRAY_AGG(DISTINCT jsonb_build_object('id', git_emails.id, 'email', git_emails.email)) FILTER (WHERE git_emails.id IS NOT NULL), '{}') AS git_emails",
+				),
+			)
+			.leftJoin("git_emails", "contributors.id", "git_emails.contributor_id")
+			.leftJoin("activity_logs", "git_emails.id", "activity_logs.git_email_id")
+			.leftJoin("projects", "activity_logs.project_id", "projects.id")
+			.groupBy("contributors.id");
+
+		return {
+			items: contributorsWithProjectsAndEmails.map((contributor) => {
+				return ContributorEntity.initialize({
+					...contributor,
+				});
+			}),
+		};
 	}
 
 	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(
@@ -48,16 +55,22 @@ class ContributorService implements Service {
 		return item.toObject();
 	}
 
-	public findAll(): ReturnType<Service["findAll"]> {
-		return Promise.resolve({ items: [] });
+	public async findAll(): Promise<ContributorGetAllResponseDto> {
+		const contributors = await this.contributorRepository.findAll();
+
+		return { items: contributors.items.map((item) => item.toObject()) };
 	}
 
 	public async findByName(
 		name: string,
 	): Promise<ContributorGetAllItemResponseDto | null> {
 		const item = await this.contributorRepository.findByName(name);
 
-		return item ? item.toObject() : null;
+		if (!item) {
+			return null;
+		}
+
+		return item.toObject();
 	}
 
 	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/projects.ts

@@ -13,4 +13,5 @@ const projectService = new ProjectService(
 );
 const projectController = new ProjectController(logger, projectService);
 
-export { projectController };
+export { projectController, projectService };
+export { ProjectService } from "./project.service.js";