Master 1.0

.gitignore

@@ -1,8 +1,9 @@
+node_modules/
+ormconfig.json/
+.env/
 .idea/
 .vscode/
-node_modules/
 build/
 tmp/
 temp/
-src/auth/
-ormconfig.json/
+src/auth/

README.md

@@ -1,6 +1,6 @@
 # Criando uma Api Rest com TypeScript e TypeORM
 
-##Passos para rodar esse projeto:
+## Passos para rodar esse projeto:
 
 1. Rode o comando `npm i` ou `yarn install` 
 2. Crie um arquivo `ormconfig.json` na raiz do seu projeto
@@ -31,7 +31,7 @@ com as seguintes informações:
 4. Rode o comando `npm start`
 
 
-<h2 style="color: #75FDA3">Dependências usadas</h2>
+<h2 style="color: green">Dependências usadas</h2>
 <ul>
     <li>TypeScript</li>
     <li>Express</li>
@@ -41,4 +41,15 @@ com as seguintes informações:
     <li>Postgres</li>
 </ul>
 
-<h3 style="color: #75FDA3">Conforme vou estudando e melhorando o código irei postando as alterações</h3>
+## O que tem nesse projeto
+
+Neste projeto eu criei uma api rest para um blog simples usando typescript, express e typeorm
+
+<h3>Nesta aplicação contem</h3>
+
+<ul>
+   <li>Criação de usuário e alteração de email e podendo deletar o mesmo</li>
+   <li>Muddleware de autenticação e geração de um token de autenticação</li>
+   <li>Cada usuário poderá criar post contendo titulo e descrição</li>
+   <li>Poderá criar, listar, atualizar e deletar os posts</li>
+</ul>

package.json

@@ -14,6 +14,7 @@
    "dependencies": {
       "bcryptjs": "^2.4.3",
       "body-parser": "^1.18.1",
+      "class-validator": "^0.13.1",
       "dotenv": "^8.2.0",
       "express": "^4.15.4",
       "jsonwebtoken": "^8.5.1",

src/controller/AuthController.ts

@@ -1,7 +1,6 @@
-import { validate } from '../auth/auth';
 import { User } from '../model/User';
 import { getRepository } from 'typeorm';
-import {Request, Response} from 'express';
+import { Request, Response } from 'express';
 import bcrypt from 'bcryptjs';
 import jwt from 'jsonwebtoken';
 
@@ -11,25 +10,27 @@ export const index = (request: Request, response: Response) => {
 
 
 export const authUser = async (request: Request, response: Response) => {
-    const {email, password} = request.body;
+    const [, hash] = request.headers.authorization.split(' ')
 
-    const verifyUser = getRepository(User);
+    const [email, password] = Buffer.from(hash, 'base64').toString().split(':');
 
-    const user = await verifyUser.findOne({ where: { email } });
+    const repository = getRepository(User);
+
+    const user = await repository.findOne({ where: { email } });
 
     if(!user) {
-        response.status(401).json({message: "User not found!"});
+        return response.status(401).json({ message: "User not found!" });
     }
 
     const isValidatePassword = await bcrypt.compare(password, user.password);
 
     if(!isValidatePassword) {
-        response.status(401).json({message: "Invalid password!"});
+        return response.status(401).json({message: "Invalid password!"});
     }
 
     delete user.password;
 
-    const token = jwt.sign({ id: user.id}, validate, { expiresIn: 86400 });
+    const token = jwt.sign({ id: user.id }, process.env.VALIDATE, { expiresIn: 86400 });
 
-    response.json({user, token});
+    return response.send({user, token});
 }

src/controller/PostControllers.ts

@@ -0,0 +1,101 @@
+import {Request, Response} from 'express';
+import { getRepository } from 'typeorm'
+import { Post } from '../model/Posts';
+import { User } from '../model/User';
+
+export const postPosts = async (request: Request, response: Response) => {
+    try {
+        const { id } = request.params;
+        const { title, description } = request.body;
+
+        const repository = getRepository(Post);
+
+        const userRepository = getRepository(User);
+
+        const user = await userRepository.findOneOrFail(id, {relations: ['posts']});
+
+        if(!user) {
+            return response.status(401).json({ message: "Cannot possibly create post with this user" });
+        }
+
+        const createPost = repository.create({ title, description, user });
+
+
+        const posts = await repository.save(createPost);
+
+        delete createPost.user;
+
+        return response.json(posts);
+    } catch (error) {
+        response.status(401).json({ erro: error })
+    }
+
+}
+
+export const getPost = async (request: Request, response: Response) => {
+    const repository = getRepository(Post);
+
+    const posts = await repository.find()
+
+    response.json(posts)
+}
+
+export const deletePost = async (request: Request, response: Response) => {
+    try {
+        const {user_id, post_id} = request.params;
+
+        const userRepository = getRepository(User)
+        const repository = getRepository(Post)
+
+        const user = await userRepository.findOne(user_id);
+
+        if(!user) {
+            return response.status(401).json({ message: "User not found." });
+        }
+
+        const post = await repository.findOne(post_id);
+
+        if(!post) {
+            return response.status(404).json({ message: "Post not found."})
+        }
+
+       await repository.delete(post_id);
+
+        return response.status(200).json({ message: "Post deleted." });
+
+    } catch (error) {
+        response.status(401).json({ erro: error })
+    }
+}
+
+export const putPost = async (request: Request, response: Response) => {
+    try {
+        const {user_id, post_id} = request.params;
+
+        const {title, description} = request.body
+
+        const userRepository = getRepository(User)
+        const repository = getRepository(Post)
+
+        const user = await userRepository.findOne(user_id);
+
+        if(!user) {
+            return response.status(401).json({ message: "User not found." });
+        }
+
+        const post = await repository.findOne(post_id);
+
+        if(!post) {
+            return response.status(404).json({ message: "Post not found."})
+        }
+
+       await repository.update(post_id, {title, description});
+
+       delete post.user
+        return response.status(200).json(post);
+
+    } catch (error) {
+        response.status(401).json({ erro: error })
+    }
+
+}

src/controller/UserController.ts

@@ -1,32 +1,56 @@
 import { Request, Response } from 'express';
 import { getRepository } from 'typeorm';
-
+import { validate } from 'class-validator'
 import { User } from '../model/User';
 
 export const getUser = async (request: Request, response: Response) => {
-    const user = await getRepository(User).find();
+    const repository = getRepository(User);
+
+    const users = await repository.find(); 
+
+    users.filter(user => delete user.password);
 
-    return response.json(user)
+    return response.json(users);
+}
+
+export const getOneUser = async (request: Request, response: Response) => {
+  const { user_id } = request.params;
+
+  const repository = getRepository(User);
+
+  const user = await repository.findOneOrFail(user_id, {
+    relations: ['posts']
+  });
+
+  user.posts.filter(post => delete post.user);
+
+  response.json(user);
 }
 
 export const postUser = async (request: Request, response: Response) => {
-    const { email, password } = request.body;
+    const { name, bio, github, email, password } = request.body;
     try {
-      const repository = getRepository(User);
-
-
-      const userAlreadyExists = await repository.findOne({ where:{ email } })
-
-      if(userAlreadyExists) { 
-        return response.status(409).json({error: "This user already exists."})
-      }
-      const user = repository.create({ email, password })
-
-      await repository.save(user);
-
-      return response.json(user);
+        const repository = getRepository(User);
+
+        const userAlreadyExists = await repository.findOne({ where: { email } });
+
+        if(userAlreadyExists) { 
+          return response.status(409).json({ error: "This user already exists." });
+        }
+
+        const user = repository.create({ name, bio, github, email, password });
+
+        const validateUser = await validate(user)
+
+        if(validateUser.length > 0) {
+          return response.json({ message: 'Verify all fields.'})
+        }
+
+        await repository.save(user);
+
+        return response.json(user);
     } catch (error) {
-        response.status(401).json({ error: "Cannot create user." })
+        response.status(401).json({ error: "Cannot create user." });
     }
 }
 
@@ -39,10 +63,11 @@ export const putEmail = async (request: Request, response: Response) => {
       const UserEmail = await repository.update(user_id, { email });
 
       if(UserEmail.affected !== 1) {
-        return response.status(404).json({message: 'User not found'})
+        return response.status(404).json({message: 'User not found'});
       }
 
       const UpdateUserEmail = await repository.findOne(user_id);
+
       return response.json(UpdateUserEmail);
     } catch (error) {
       response.status(401).json({Message: "Cannot update user email."});

src/database/migration/1613080870691-CreateUserTable.ts

@@ -15,19 +15,39 @@ export class CreateUserTable1613080870691 implements MigrationInterface {
                   generationStrategy: 'uuid',
                   default: 'uuid_generate_v4()'
                 },
+                {
+                  name: 'name',
+                  type: 'varchar',
+                  isNullable: false,
+                },
+                {
+                  name: 'bio',
+                  type: 'varchar',
+                },
+                {
+                  name: 'github',
+                  type: 'varchar',
+                },
                 {
                   name: 'email',
                   type: 'varchar',
                   isUnique: true,
+                  isNullable: false,
                 }, 
                 {
                   name: 'password',
                   type: 'varchar',
+                  isNullable: false,
                 },
                 {
                   name: 'created_at',
                   type: 'timestamp',
                   default: 'now()'
+                },
+                {
+                  name: 'updated_at',
+                  type: 'timestamp',
+                  default: 'now()'
                 }
             ],
         }))