improve project controller typings

server/src/controller/project.controller.ts

@@ -1,53 +1,68 @@
 import { Router } from "express";
 import { ProjectDto } from "../dto/poject.dto";
+import { NewProjectDto } from "../dto/project.new.dto";
+import { UpdateProjectDto } from "../dto/project.update.dto";
 import { ProjectService } from "../service/project.service";
+import {
+  CreateResponse, DeleteResponse, IndexResponse,
+  UpdateResponse
+} from "./typings/responses";
 
 const router = Router();
 export const ProjectRoutes = router;
 
 export const apiNamespace = "/projects";
 
-router.get(apiNamespace, async (req, res) => {
+router.get<typeof apiNamespace, IndexResponse<ProjectDto>>(
+  apiNamespace,
+  async (req, res) => {
     const projects = await ProjectService.listAllByUserId(req.userId);
 
-  const response: ProjectDto[] = projects.map<ProjectDto>((project) => ({
+    res.json({
+      data: projects.map<ProjectDto>((project) => ({
         id: project.id,
         name: project.name,
-  }));
+      })),
-
-  res.json({
-    data: response
-  });
     });
+  }
+);
 
-router.post(apiNamespace, (req, res) => {
+router.post<typeof apiNamespace, unknown, CreateResponse<ProjectDto>, NewProjectDto>(
+  apiNamespace,
+  (req, res) => {
     const { name } = req.body;
 
-  ProjectService.create({
+    ProjectService.create(req.userId, {
       name,
-    userId: req.userId,
     })
       .then((project) => {
-      const respose: ProjectDto = {
+        res.json({
+          data: {
             id: project.id,
             name: project.name,
-      };
+          },
-
+        });
-      res.json(respose);
       })
       .catch((err) => {
         res.status(422).json({
-        error: err.message,
+          errors: [err.message],
-      });
         });
       });
+  }
+);
 
-router.put(`${apiNamespace}/:id`, async (req, res) => {
+const putPath = `${apiNamespace}/:taskId`;
-  const { id } = req.params;
+router.put<typeof putPath, { taskId: string }, UpdateResponse<ProjectDto>, UpdateProjectDto>(
+  putPath,
+  async (req, res) => {
+    const { taskId } = req.params;
     const { name } = req.body;
-  const projectId = parseInt(id);
+    const projectId = parseInt(taskId);
 
-  const projectToBeUpdated = await ProjectService.findProjectFromUserById(req.userId, projectId);
+    const projectToBeUpdated = await ProjectService.findProjectFromUserById(
+      req.userId,
+      projectId
+    );
 
     if (projectToBeUpdated) {
       ProjectService.update(projectToBeUpdated, {
@@ -61,16 +76,23 @@ router.put(`${apiNamespace}/:id`, async (req, res) => {
       });
     } else {
       res.status(404).json({
-      error: "Project not found",
+        errors: ["Project not found"],
       });
     }
-});
+  }
+);
 
-router.delete(`${apiNamespace}/:id`, async (req, res) => {
+const deletePath = `${apiNamespace}/:taskId`;
-  const { id } = req.params;
+router.delete<typeof deletePath, { taskId: string }, DeleteResponse>(
-  const projectId = parseInt(id);
+  deletePath,
+  async (req, res) => {
+    const { taskId } = req.params;
+    const projectId = parseInt(taskId);
 
-  const projecToBeDeleted = await ProjectService.findProjectFromUserById(req.userId, projectId);
+    const projecToBeDeleted = await ProjectService.findProjectFromUserById(
+      req.userId,
+      projectId
+    );
 
     if (projecToBeDeleted) {
       const success = await ProjectService.destroy(projecToBeDeleted);
@@ -79,12 +101,13 @@ router.delete(`${apiNamespace}/:id`, async (req, res) => {
         res.json({ success });
       } else {
         res.status(422).json({
-        error: "Could not delete project",
+          errors: ["Could not delete project"],
         });
       }
     } else {
       res.status(404).json({
-      error: "Project not found",
+        errors: ["Project not found"],
       });
     }
-});
+  }
+);

server/src/controller/typings/responses.d.ts

@@ -0,0 +1,25 @@
+export type ErrorResponse = {
+  errors: string[];
+};
+
+export type IndexResponse<TData> = {
+  data: TData[];
+};
+
+export type CreateResponse<TData> =
+  | {
+      data: TData;
+    }
+  | ErrorResponse;
+
+export type UpdateResponse<TData> =
+  | {
+      data: TData;
+    }
+  | ErrorResponse;
+
+export type DeleteResponse =
+  | {
+      success: boolean;
+    }
+  | ErrorResponse;

server/src/dto/project.new.dto.ts

@@ -1,4 +1,3 @@
 export type NewProjectDto = {
   name: string
-  userId: number
 }

server/src/dto/project.update.dto.ts

@@ -1,3 +1,3 @@
 export type UpdateProjectDto = {
-  name: string
+  name?: string
 }

server/src/service/project.service.ts

@@ -1,14 +1,17 @@
 import { validate } from "class-validator";
-import { NewProjectDto } from "../dto/newProject.dto";
+import { NewProjectDto } from "../dto/project.new.dto";
-import { UpdateProjectDto } from "../dto/updateProject.dto";
+import { UpdateProjectDto } from "../dto/project.update.dto";
 import { Project } from "../entity/project.entity";
 import { User } from "../entity/user.entity";
 import { projectRepository } from "../repository/project.repository";
 import { UserService } from "./user.service";
 
-async function create(newProject: NewProjectDto): Promise<Project> {
+async function create(
+  userId: User["id"],
+  newProject: NewProjectDto
+): Promise<Project> {
   const project = new Project();
-  const user = await UserService.findUserById(newProject.userId);
+  const user = await UserService.findUserById(userId);
 
   project.name = newProject.name;
   project.user = user;
@@ -40,9 +43,9 @@ async function destroy(project: Project): Promise<boolean> {
 
 async function update(
   project: Project,
-  updateProjectDto: UpdateProjectDto
+  data: UpdateProjectDto
 ): Promise<boolean> {
-  projectRepository.merge(project, updateProjectDto);
+  projectRepository.merge(project, data);
   const updateResult = await projectRepository.save(project);
 
   return !!updateResult;
@@ -64,5 +67,5 @@ export const ProjectService = {
   listAllByUserId,
   destroy,
   update,
-  findProjectFromUserById
+  findProjectFromUserById,
 };

server/src/service/task.service.ts

@@ -1,4 +1,4 @@
-import { NewTaskDto } from "../dto/newTask.dto";
+import { NewTaskDto } from "../dto/task.new.dto";
 import { Project } from "../entity/project.entity";
 import { Task } from "../entity/task.entity";
 import { taskRepository } from "../repository/task.repository";

server/src/service/user.service.ts

@@ -1,5 +1,5 @@
 import { validate } from "class-validator"
-import { NewUserDto } from "../dto/newUser.dto"
+import { NewUserDto } from "../dto/user.new.dto"
 import { User } from "../entity/user.entity"
 import { userRepository } from "../repository/user.repository"
 import { AuthService } from "./auth.service"