nested routing (#8)

nmanikiran · curioustushar · web-flow · commit fdc882521879 · 2021-05-01T15:02:30.000+05:30
* audit fix

* update dependencies

* coverted promise to async await

* migrated code to nested routing

Co-authored-by: Tushar Gupta &lt;cse.tushar@gmail.com&gt;
diff --git a/Readme.MD b/Readme.MD
@@ -18,19 +18,18 @@ If you found this project useful, then please consider giving it a ⭐️ on Git
 
 1. You need to install PostgreSQL
 
+   - For Windows
+     - Install PostgreSQL and set following environment variable
+       `C:\Program Files\PostgreSQL\10\bin`,
+       `C:\Program Files\PostgreSQL\10\lib`
+   - For Ubuntu
 
-    - For Windows
-      - Install PostgreSQL and set following environment variable
-        `C:\Program Files\PostgreSQL\10\bin`,
-        `C:\Program Files\PostgreSQL\10\lib`
-    - For Ubuntu
+     - Installation
+       `sudo apt update`
+       `sudo apt-get install postgresql postgresql-contrib`
 
-      - Installation
-        `sudo apt update`
-        `sudo apt-get install postgresql postgresql-contrib`
-
-      - Manage `PostgreSQL` service
-        `sudo systemctl {status | start | restart | stop} postgresql`
+     - Manage `PostgreSQL` service
+       `sudo systemctl {status | start | restart | stop} postgresql`
 
 2. rename `.env-sample` to `.env` in the file the DB connection string need to be updated according to your `credentials`.
    ex : `postgres://<YourUserName>:<YourPassword>@localhost:5432/<YourDatabase>`
@@ -54,14 +53,14 @@ you can change port in `.env` file check `.env-sample`
 ```
 src
 └───index.ts          # Application entry point
-└───routes.ts         # Application routes / endpoints
+└───routes            # Application routes / endpoints
 └───controllers       # Express route controllers for all the endpoints of the app
+└───repositories      # All the database interaction logic is here
 └───db                # DB related files like connection / seed data
 └───handlers          # Common logic
 └───logs              # application logs
 └───middlewares       # express middlewares
 └───models            # DB Models (Postgress)
-└───repositories      # All the database interaction logic is here
 └───validators        # API Request object validations
 
 ```
diff --git a/package-lock.json b/package-lock.json
diff --git a/server.ts b/server.ts
@@ -9,13 +9,13 @@ const app: Application = express();
 const server: Server = new Server(app);
 const port: number = parseInt(process.env.port, 10) || 3000;
 
-app.listen(port, 'localhost', function() {
+app.listen(port, 'localhost', function () {
   console.info(`Server running on : http://localhost:${port}`);
 }).on('error', (err: any) => {
-    if (err.code === 'EADDRINUSE') {
-      console.log('server startup error: address already in use');
-    }
-    else {
-      console.log(err);
-    }
+  if (err.code === 'EADDRINUSE') {
+    console.log('server startup error: address already in use');
+  }
+  else {
+    console.log(err);
+  }
 });
diff --git a/src/controllers/CoursesCtrl.ts b/src/controllers/CoursesCtrl.ts
@@ -1,29 +1,29 @@
-import { Router, Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction } from 'express';
 import CourseRepo from './../repositories/CoursesRepo';
 import { apiErrorHandler } from './../handlers/errorHandler';
 
-export default class CoursesRoutes {
-  constructor() {}
+export default class CoursesCtrl {
+  constructor() { }
 
-  getAllCourses(req: Request, res: Response, next: NextFunction) {
-    CourseRepo.getAllCourses({ order: ['seqNo'] })
-      .then(result => res.json(result))
-      .catch(err => {
-        apiErrorHandler(err, req, res, 'Fetch All Courses failed.');
-      });
+  async getAllCourses(req: Request, res: Response, next: NextFunction) {
+    try {
+      const courseList = await CourseRepo.getAllCourses({ order: ['seqNo'] })
+      res.json(courseList);
+    } catch (error) {
+      apiErrorHandler(error, req, res, 'Fetch All Courses failed.');
+    }
   }
 
-  getCourseDetails(req: Request, res: Response, next: NextFunction) {
-    CourseRepo.getById(req.params.id)
-      .then(result => {
-        if (result) {
-          return res.json(result);
-        } else {
-          res.status(404).send(`Lesson ${req.params.id} not found.`);
-        }
-      })
-      .catch(err => {
-        apiErrorHandler(err, req, res, `Course ${req.params.id} is failed.`);
-      });
+  async getCourseDetails(req: Request, res: Response, next: NextFunction) {
+    try {
+      const courseDetails = await CourseRepo.getById(req.params.id);
+      if (courseDetails) {
+        return res.json(courseDetails);
+      } else {
+        res.status(404).send(`Lesson ${req.params.id} not found.`);
+      }
+    } catch (error) {
+      apiErrorHandler(error, req, res, `Course ${req.params.id} is failed.`);
+    }
   }
 }
diff --git a/src/controllers/LessonsCtrl.ts b/src/controllers/LessonsCtrl.ts
@@ -1,78 +1,82 @@
-import { NextFunction, Request, Response, Router } from 'express';
+import { Request, Response, NextFunction } from 'express';
 import { apiErrorHandler } from '../handlers/errorHandler';
 import LessonRepo from '../repositories/LessonsRepo';
 
-export default class LessonRoutes {
-  constructor() {}
+export default class LessonsCtrl {
+  constructor() { }
 
-  getAllLessons(req: Request, res: Response, next: NextFunction) {
-    LessonRepo.getAllLessons({ order: ['id'] })
-      .then(result => res.json(result))
-      .catch(err => {
-        apiErrorHandler(err, req, res, 'Fetch All Lessons failed.');
-      });
+  async getAllLessons(req: Request, res: Response, next: NextFunction) {
+    try {
+      const lessons = await LessonRepo.getAllLessons({ order: ['id'] });
+      res.json(lessons);
+    } catch (error) {
+      apiErrorHandler(error, req, res, 'Fetch All Lessons failed.');
+    }
   }
 
-  getLessonByCourse(req: Request, res: Response, next: NextFunction) {
-    LessonRepo.getLessonByCourse(req.params.id)
-      .then(result => res.json(result))
-      .catch(err => {
-        apiErrorHandler(
-          err,
-          req,
-          res,
-          `Lessons in course ${req.params.id} failed.`,
-        );
-      });
+  async getLessonByCourse(req: Request, res: Response, next: NextFunction) {
+    try {
+      const lesson = await LessonRepo.getLessonByCourse(req.params.id);
+      res.json(lesson);
+    } catch (error) {
+      apiErrorHandler(
+        error,
+        req,
+        res,
+        `Lessons in course ${req.params.id} failed.`,
+      );
+    }
   }
 
-  getLessonById(req: Request, res: any, next: NextFunction) {
-    LessonRepo.getLessonById(req.params.id)
-      .then(result => {
-        if (result) {
-          return res.json(result);
-        } else {
-          res.status(404).send(`Lesson ${req.params.id} not found.`);
-        }
-      })
-      .catch(err => {
-        apiErrorHandler(err, req, res, `Lesson ${req.params.id} failed.`);
-      });
+  async getLessonById(req: Request, res: any, next: NextFunction) {
+    try {
+      const result = await LessonRepo.getLessonById(req.params.id);
+      if (result) {
+        return res.json(result);
+      } else {
+        res.status(404).send(`Lesson ${req.params.id} not found.`);
+      }
+    } catch (error) {
+      apiErrorHandler(error, req, res, `Lesson ${req.params.id} failed.`);
+    }
   }
 
-  createLesson(req: Request, res: Response, next: NextFunction) {
-    LessonRepo.createLesson(req['value']['body'])
-      .then(result => res.json(result))
-      .catch(err => {
-        apiErrorHandler(err, req, res, 'Creation of Lesson failed.');
-      });
+  async createLesson(req: Request, res: Response, next: NextFunction) {
+    try {
+      const result = await LessonRepo.createLesson(req['value']['body']);
+      res.json(result);
+    } catch (error) {
+      apiErrorHandler(error, req, res, 'Creation of Lesson failed.');
+    }
   }
 
-  updateLesson(req: Request, res: Response, next: NextFunction) {
+  async updateLesson(req: Request, res: Response, next: NextFunction) {
     const id = parseInt(req.params.id);
-    LessonRepo.updateLesson(id, req['value']['body'])
-      .then(result => res.json(result))
-      .catch(err => {
-        apiErrorHandler(
-          err,
-          req,
-          res,
-          `updation of Lesson ${req.params.id} is failed.`,
-        );
-      });
+    try {
+      const result = await LessonRepo.updateLesson(id, req['value']['body']);
+      res.json(result);
+    } catch (error) {
+      apiErrorHandler(
+        error,
+        req,
+        res,
+        `updation of Lesson ${req.params.id} is failed.`,
+      );
+    }
   }
 
-  deleteLesson(req: Request, res: Response, next: NextFunction) {
+  async deleteLesson(req: Request, res: Response, next: NextFunction) {
     const id = parseInt(req.params.id);
-    LessonRepo.deleteLesson(id)
-      .then(result => res.json(result))
-      .catch(err => {
-        apiErrorHandler(
-          err,
-          req,
-          res,
-          `deletion of Lesson ${req.params.id}  is failed.`,
-        );
-      });
+    try {
+      const result = await LessonRepo.deleteLesson(id);
+      res.json(result);
+    } catch (error) {
+      apiErrorHandler(
+        error,
+        req,
+        res,
+        `deletion of Lesson ${req.params.id}  is failed.`,
+      );
+    }
   }
 }
diff --git a/src/routes.ts b/src/routes.ts
diff --git a/src/routes/CourseRoutes.ts b/src/routes/CourseRoutes.ts
@@ -0,0 +1,16 @@
+import { Router } from 'express';
+import CoursesCtrl from '../controllers/CoursesCtrl';
+
+class CourseRoutes {
+  router = Router();
+  coursesCtrl = new CoursesCtrl();
+
+  constructor() {
+    this.intializeRoutes();
+  }
+  intializeRoutes() {
+    this.router.route('/').get(this.coursesCtrl.getAllCourses);
+    this.router.route('/:id').get(this.coursesCtrl.getCourseDetails);
+  }
+}
+export default new CourseRoutes().router;
diff --git a/src/routes/LessonRoutes.ts b/src/routes/LessonRoutes.ts
@@ -0,0 +1,34 @@
+import { Router } from 'express';
+import LessonsCtrl from '../controllers/LessonsCtrl';
+import { LessonValidator, lessonSchema } from '../validators/lessonValidator';
+
+class LessonRoutes {
+  router = Router();
+  lessonsCtrl = new LessonsCtrl();
+  lessonValidator = new LessonValidator();
+
+  constructor() {
+    this.intializeRoutes();
+  }
+
+  intializeRoutes() {
+
+    this.router.route('/').get(this.lessonsCtrl.getAllLessons);
+    this.router.route('/course/:id')
+      .get(this.lessonsCtrl.getLessonByCourse);
+    this.router.route('/:id').get(this.lessonsCtrl.getLessonById);
+    this.router.route('/')
+      .post(
+        this.lessonValidator.validateBody(lessonSchema),
+        this.lessonsCtrl.createLesson
+      );
+    this.router.route('/:id')
+      .put(
+        this.lessonValidator.validateBody(lessonSchema),
+        this.lessonsCtrl.updateLesson
+      );
+    this.router.route('/:id').delete(this.lessonsCtrl.deleteLesson);
+  }
+}
+
+export default new LessonRoutes().router;
diff --git a/src/routes/index.ts b/src/routes/index.ts
@@ -0,0 +1,13 @@
+import { Application } from 'express';
+import courseRouter from './CourseRoutes';
+import lessonRouter from './LessonRoutes'
+
+export default class Routes {
+
+  constructor(app: Application) {
+    // course reoutes
+    app.use('/api/courses', courseRouter);
+    // lesson routes
+    app.use('/api/lessons', lessonRouter);
+  }
+}
diff --git a/src/validators/lessonValidator.ts b/src/validators/lessonValidator.ts
