Merge pull request #3 from kennie-larkson/authentication

Authentication

Author: kennie-larkson

src/app.ts

@@ -4,7 +4,6 @@ import cors from "cors";
 import errorMiddleware from "./middleware/error.middleware";
 import IController from "./interfaces/controller.interface";
 import AppDataSource from "./data-source";
-import { userController } from "./entity/users/user.controller";
 
 class App {
   public app: express.Application;

src/authentication/authentication.controller.ts

@@ -0,0 +1,38 @@
+import express, { Request, Response, NextFunction } from "express";
+import AuthenticationService from "./authentication.service";
+import { ICreateUser } from "./../entity/users/user.interface";
+import { validateUserForm } from "./../middleware/validation.middleware";
+
+export default class AuthController {
+  public path = "/auth";
+  public router = express.Router();
+  private authService = new AuthenticationService();
+
+  constructor() {
+    this.initializeRoutes();
+  }
+
+  private initializeRoutes() {
+    this.router.post(
+      `${this.path}/register`,
+      validateUserForm,
+      this.registration
+    );
+  }
+
+  private registration = async (
+    request: express.Request,
+    response: express.Response,
+    next: express.NextFunction
+  ) => {
+    const userData: ICreateUser = request.body;
+    try {
+      const { cookie, user } = await this.authService.register(userData);
+      console.log({ user, cookie });
+      response.setHeader("Set-Cookie", [cookie]);
+      response.send(user);
+    } catch (error) {
+      next(error);
+    }
+  };
+}

src/authentication/authentication.service.ts

@@ -0,0 +1,46 @@
+import bcrypt from "bcrypt";
+import { ICreateUser } from "entity/users/user.interface";
+import jwt from "jsonwebtoken";
+import AppDataSource from "./../data-source";
+import User from "./../entity/users/user.entity";
+import ITokenData from "./../interfaces/tokenData.interface";
+import IDataStoredInToken from "./../interfaces/dataStoredInToken.interface";
+
+export default class AuthenticationService {
+  public async register(userData: ICreateUser) {
+    if (
+      await AppDataSource.manager
+        .getRepository(User)
+        .findOneBy({ email: userData.email })
+    ) {
+      throw new Error(
+        "Sorry there is a user with that email already. Please, try another."
+      );
+    }
+
+    const hashedPassword = await bcrypt.hash(userData.password, 10);
+
+    const user = AppDataSource.manager.getRepository(User).create({
+      ...userData,
+      password: hashedPassword,
+    });
+    await AppDataSource.manager.getRepository(User).save(user);
+    delete user.password;
+    const tokenData = this.createToken(user);
+    const cookie = this.createCookie(tokenData);
+
+    return { user, cookie };
+  }
+
+  public createToken(user: User): ITokenData {
+    const expiresIn = 60 * 60;
+    const secret = process.env.JWT_SECRET;
+    const dataStoredInToken: IDataStoredInToken = { id: user.id };
+
+    return { expiresIn, token: jwt.sign(dataStoredInToken, secret, {}) };
+  }
+
+  public createCookie(tokenData: ITokenData) {
+    return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn}`;
+  }
+}

src/data-source.ts

@@ -1,4 +1,5 @@
-import "reflect-metadata";
+import "dotenv/config";
+//import "reflect-metadata";
 import { DataSource } from "typeorm";
 import User from "./entity/users/user.entity";
 import Post from "./entity/posts/post.entity";

src/entity/posts/post.controller.ts

@@ -1,33 +1,94 @@
 import express from "express";
 import IPost from "./post.interface";
+import { validatePostForm } from "./../../middleware/validation.middleware";
 
 import AppDataSource from "./../../data-source";
 import { NextFunction, Request, Response } from "express";
 import Post from "./post.entity";
 
 export default class PostController {
-  public path = "/post";
+  public path = "/posts";
   public router = express.Router();
 
-  async all(request: Request, response: Response, next: NextFunction) {
-    return AppDataSource.manager.find(Post);
+  constructor() {
+    this.initializeRoutes();
   }
 
-  async one(request: Request, response: Response, next: NextFunction) {
+  private initializeRoutes() {
+    this.router.get(this.path, this.getAllPosts);
+    this.router.get(`${this.path}/:id`, this.getPostById);
+    this.router.post(`${this.path}`, validatePostForm, this.createPost);
+    this.router.delete(`${this.path}/:id`, this.removePost);
+    this.router.patch(`${this.path}/:id`, this.updatePost);
+  }
+
+  public async getAllPosts(
+    request: Request,
+    response: Response,
+    next: NextFunction
+  ) {
+    try {
+      const posts = await AppDataSource.manager
+        .getRepository(Post)
+        .find({ relations: { author: true } });
+      return response.json(posts);
+    } catch (error) {
+      return response.json(error);
+    }
+  }
+
+  async getPostById(request: Request, response: Response, next: NextFunction) {
     const { id } = request.params;
     return AppDataSource.manager.findOneBy(Post, { id: Number(id) });
   }
 
-  async save(request: Request, response: Response, next: NextFunction) {
+  async createPost(request: Request, response: Response, next: NextFunction) {
     const post: IPost = request.body;
-    return AppDataSource.manager.save(post);
+    //const post = request.body;
+    try {
+      const createdPost = AppDataSource.manager
+        .getRepository(Post)
+        .create(post);
+      const result = await AppDataSource.manager
+        .getRepository(Post)
+        .save(createdPost);
+      return response.json(result);
+    } catch (error) {
+      return response.json(error);
+    }
   }
 
-  async remove(request: Request, response: Response, next: NextFunction) {
+  async removePost(request: Request, response: Response, next: NextFunction) {
     const { id } = request.params;
     let postToRemove = await AppDataSource.manager.findOneBy(Post, {
       id: Number(id),
     });
     await AppDataSource.manager.remove(postToRemove);
   }
+
+  async updatePost(request: Request, response: Response, next: NextFunction) {
+    const { id } = request.params;
+    const update = request.body;
+    console.log(update);
+
+    try {
+      const postToUpdate = await AppDataSource.getRepository(Post).findOneBy({
+        id: Number(id),
+      });
+      if (!postToUpdate) {
+        return response.json({ message: `Unable to find post with id ${id}` });
+      }
+      AppDataSource.getRepository(Post).merge(postToUpdate, update);
+      const updatedPost = await AppDataSource.getRepository(Post).save(
+        postToUpdate
+      );
+
+      return response.json({
+        message: `Successfully updated data for post with id: ${id}.`,
+        updatedPost,
+      });
+    } catch (error) {
+      return response.json(error);
+    }
+  }
 }

src/entity/posts/post.entity.ts

@@ -1,19 +1,20 @@
-import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
+import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from "typeorm";
 import "reflect-metadata";
+import User from "../users/user.entity";
 
 @Entity()
 class Post {
   @PrimaryGeneratedColumn()
   public id?: number;
 
   @Column()
-  public author?: string;
+  public content: string;
 
   @Column()
-  public content?: string;
+  public title: string;
 
-  @Column()
-  public title?: string;
+  @ManyToOne(() => User, (author) => author.posts)
+  public author: User;
 }
 
 export default Post;

src/entity/posts/post.interface.ts

@@ -1,8 +1,9 @@
+import User from "entity/users/user.entity";
+
 interface IPost {
-  id: number;
-  author: string;
   content: string;
   title: string;
+  author: Partial<User>;
 }
 
 export default IPost;

src/entity/topic/topic.controller.ts

@@ -1,28 +1,103 @@
 import AppDataSource from "src/data-source";
-import { NextFunction, Request, Response } from "express";
+import express, { NextFunction, Request, Response } from "express";
 import Topic from "./topic.entity";
-import ITopic from "./topic.interface";
+import { ICreateTopic } from "./topic.interface";
 
 export default class TopicController {
-  async all(request: Request, response: Response, next: NextFunction) {
-    return AppDataSource.manager.find(Topic);
+  public path = "/topics";
+  public router = express.Router();
+
+  constructor() {
+    this.initializeRoutes();
+  }
+
+  private initializeRoutes() {
+    this.router.get(this.path, this.getAllTopics);
+    this.router.get(`${this.path}/:id`, this.getTopicById);
+    this.router.post(`${this.path}`, this.createTopic);
+    this.router.delete(`${this.path}/:id`, this.removeTopic);
+    this.router.patch(`${this.path}/:id`, this.updateTopic);
   }
 
-  async one(request: Request, response: Response, next: NextFunction) {
-    return AppDataSource.manager.findOneBy(Topic, {
-      id: Number(request.params.id),
-    });
+  async getAllTopics(request: Request, response: Response, next: NextFunction) {
+    try {
+      const topics = await AppDataSource.manager.getRepository(Topic).find();
+      return response.json(topics);
+    } catch (error) {
+      return response.json(error);
+    }
   }
 
-  async save(request: Request, response: Response, next: NextFunction) {
-    const topic: ITopic = request.body;
-    return AppDataSource.manager.save(topic);
+  async getTopicById(request: Request, response: Response, next: NextFunction) {
+    const { id } = request.params;
+    try {
+      const topic = AppDataSource.manager.getRepository(Topic).findOneBy({
+        id: Number(id),
+      });
+      if (!topic) {
+        return response.json({ message: `Unable to find user with id ${id}` });
+      }
+      return response.json(topic);
+    } catch (error) {
+      return response.json(error);
+    }
+  }
+
+  async createTopic(request: Request, response: Response, next: NextFunction) {
+    const topic: ICreateTopic = request.body;
+
+    try {
+      const createdTopic = AppDataSource.getRepository(Topic).create(topic);
+      const results = await AppDataSource.getRepository(Topic).save(
+        createdTopic
+      );
+      return response.send(results);
+    } catch (error) {
+      return response.json(error);
+    }
   }
 
-  async remove(request: Request, response: Response, next: NextFunction) {
-    let topicToRemove = await AppDataSource.manager.findOneBy(Topic, {
-      id: Number(request.params.id),
-    });
-    await AppDataSource.manager.remove(topicToRemove);
+  async removeTopic(request: Request, response: Response, next: NextFunction) {
+    const { id } = request.params;
+
+    try {
+      const removedUser = await AppDataSource.getRepository(Topic).delete(id);
+      if (removedUser.affected === 0) {
+        return response.json(
+          `Unable to find topic with id: ${id} for deletion.`
+        );
+      }
+      return response.json({
+        message: `Successfully deleted records of topic with id: ${id}.`,
+      });
+    } catch (error) {
+      return response.json(error);
+    }
+  }
+
+  async updateTopic(request: Request, response: Response, next: NextFunction) {
+    const { id } = request.params;
+    const update: Partial<Topic> = request.body;
+    console.log(update);
+
+    try {
+      const topicToUpdate = await AppDataSource.getRepository(Topic).findOneBy({
+        id: Number(id),
+      });
+      if (!topicToUpdate) {
+        return response.json({ message: `Unable to find topic with id ${id}` });
+      }
+      AppDataSource.getRepository(Topic).merge(topicToUpdate, update);
+      const updatedUser = await AppDataSource.getRepository(Topic).save(
+        topicToUpdate
+      );
+
+      return response.json({
+        message: `Successfully updated data for topic with id: ${id}.`,
+        updatedUser,
+      });
+    } catch (error) {
+      return response.json(error);
+    }
   }
 }

src/entity/topic/topic.entity.ts

@@ -1,5 +1,4 @@
 import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
-//import "reflect-metadata";
 
 @Entity()
 class Topic {

src/entity/topic/topic.interface.ts

@@ -1,6 +1,4 @@
-interface ITopic {
+export interface ICreateTopic {
   topic: string;
   domain: string;
 }
-
-export default ITopic;