user module

Author: Pablo Henrique

README.md

@@ -18,3 +18,19 @@ nodemon -D
 
 Criando setup Ininical - Referencias.
 https://dev.to/melquisedecfelipe/configurando-eslint-no-node-com-express-e-typescript-58p9
+
+
+
+- Recursos nescessários na api
+
+
+- Usuário
+ [ ] Cadastrar novo usuário
+ [ ] Efeturar login e retornar token de acesso
+
+- PIX
+ [ ] Efetuar solicitação de PIX
+ [ ] Receber PIX
+ 
+ Regras: 
+  - quando receber um pix, salvar na tabela de transação

docker-compose.yaml

@@ -0,0 +1,13 @@
+version: '3.1'
+
+services:
+ db:
+    container_name: dio
+    image: postgres
+    restart: always
+    ports:
+      - 5432:5432
+    environment:
+      POSTGRES_USER: admin
+      POSTGRES_PASSWORD: dio-inter
+      POSTGRES_DB: inter

ormconfig.json

@@ -0,0 +1,12 @@
+{
+    "name":"default",
+    "type": "postgres",
+    "host": "localhost",
+    "port": 5432,
+    "username": "admin",
+    "password": "dio-inter",
+    "database": "inter",
+    "entities": ["src/entity/*.ts"],
+    "logging": false,
+    "synchronize": true
+  }

package.json

@@ -10,11 +10,21 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@types/cors": "^2.8.12",
+    "cors": "^2.8.5",
     "eslint": "^8.3.0",
-    "express": "^4.17.1"
+    "express": "^4.17.1",
+    "express-async-errors": "^3.1.1",
+    "express-jwt": "^6.1.0",
+    "jsonwebtoken": "^8.5.1",
+    "nodemon": "^2.0.15",
+    "postgre": "^0.1.8",
+    "reflect-metadata": "^0.1.13",
+    "typeorm": "^0.2.41"
   },
   "devDependencies": {
     "@types/express": "^4.17.13",
+    "@types/jsonwebtoken": "^8.5.6",
     "@types/node": "^16.11.9",
     "@typescript-eslint/eslint-plugin": "^5.4.0",
     "@typescript-eslint/parser": "^5.4.0",

src/@types/express.d.ts

@@ -0,0 +1,7 @@
+declare namespace Express {
+    export interface Request {
+        user: {
+            id: string;
+        };
+    }
+}

src/config/auth.ts

@@ -0,0 +1,7 @@
+
+export default {
+    jwt: {
+        secret: process.env.APP_SECRET || 'default',
+        expiresIn: '14d',
+    },
+};

src/entity/User.ts

@@ -0,0 +1,30 @@
+import {Entity, Column, PrimaryGeneratedColumn} from "typeorm";
+
+@Entity()
+export class User {
+
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @Column()
+    firstName: string;
+
+    @Column()
+    lastName: string;
+
+    @Column()
+    accountNumber: number;
+    
+    @Column()
+    accountDigit: number;
+    
+    @Column()
+    wallet: number;
+
+    @Column()
+    email: string;
+
+    @Column()
+    password: string;
+
+}

src/index.ts

@@ -1,10 +1,25 @@
+
+import 'express-async-errors';
 import express from 'express';
+import { createConnection } from 'typeorm';
+import cors from 'cors';
 
-const app = express();
-const PORT = 3333;
+import {globalErrors} from './middlewares/globalErros'
+import routes from './routes';
 
-app.get('/', (req, res) => res.send('Express + TypeScript Server'));
+createConnection().then(connection => {
+  const app = express();
+  const PORT = 3333;
+  
+  app.use(cors())
+  app.use(express.json())
+  app.use(routes);
 
-app.listen(PORT, () => {
-  console.log(`⚡️[server]: Server is running at http://localhost:${PORT}`);
+  app.use(globalErrors);
+  
+  app.listen(PORT, () => {
+    console.log(`⚡️[server]: Server is running at http://localhost:${PORT}`);
+  });
+}).catch(() => {
+  console.log("Unable to connect to the database")
 });

src/middlewares/globalErros.ts

@@ -0,0 +1,23 @@
+import { Request, Response, NextFunction } from 'express'
+import AppError from '../shared/error/AppError'
+
+function globalErrors(err: Error, request: Request, response: Response, next: NextFunction) {
+
+  if (err instanceof AppError) {
+    response.status(err.statusCode).json({
+      status: 'error',
+      message: err.message,
+      data: err?.data
+    });
+  }
+
+  console.error(err);
+
+  return response.status(500).json({
+    status: 'error',
+    message: 'Internal server error'
+  });
+
+}
+
+export { globalErrors };

src/middlewares/userAuthenticated.ts

@@ -0,0 +1,42 @@
+import { Request, Response, NextFunction } from 'express';
+import { verify } from 'jsonwebtoken';
+import authConfig from '../config/auth';
+
+import AppError from '../shared/error/AppError';
+
+interface ITokenPlayload {
+    iat: number;
+    exp: number;
+    sub: string;
+}
+
+export default function ensureAuthenticated(
+    req: Request,
+    res: Response,
+    next: NextFunction,
+): void {
+    // Validação do token JWT
+
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader) {
+        throw new AppError('Não foi enviado o JWT', 401);
+    }
+
+    const [, token] = authHeader.split(' ');
+
+    try {
+        const decoded = verify(token, authConfig.jwt.secret);
+
+        const { sub } = decoded as ITokenPlayload;
+
+        req.user = {
+            id: sub,
+        };
+
+        return next();
+    } catch {
+        throw new AppError('token JWT inválido', 401);
+    }
+}
+

src/resources/user/dtos/user.signin.dtos.ts

@@ -0,0 +1,4 @@
+export interface UserSignIn {
+    email: string;
+    password: string;
+}

src/resources/user/dtos/user.signup.dtos.ts

@@ -0,0 +1,6 @@
+export interface UserSignUp {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+}

src/resources/user/user.controllers.ts

@@ -0,0 +1,20 @@
+import { Request, Response} from 'express';
+
+import UserService from './user.service';
+
+export default class UserController {
+
+    
+    async signin (req: Request, res: Response) {
+        const {email, password} = req.body;
+        const userService = new UserService();
+        const users = await userService.signin({email, password});
+        return res.status(200).send(users)
+    }
+
+    async signup (req: Request, res: Response) {
+        const userService = new UserService();
+        const users = await userService.signup(req.body);
+        return res.status(201).send(users)
+    }
+}

src/resources/user/user.service.ts

@@ -0,0 +1,71 @@
+import {getRepository} from "typeorm"
+import { sign } from 'jsonwebtoken';
+import {User} from '../../entity/User';
+import AppError from '../../shared/error/AppError';
+import authConfig from '../../config/auth';
+
+import {UserSignIn} from './dtos/user.signin.dtos'
+import {UserSignUp} from './dtos/user.signup.dtos'
+
+export default class UserService {
+
+
+    async signin(user: UserSignIn) {
+       const userRepository = getRepository(User);
+       const existUser = await userRepository.findOne({where: {email: user.email, password: user.password}})
+
+       if(!existUser){
+         throw new AppError('Usuário não encontrato', 401);
+       }
+
+
+       const { secret, expiresIn } = authConfig.jwt;
+
+       const token = sign({
+           firstName: existUser.firstName,
+           lastName: existUser.lastName,
+           accountNumber: existUser.accountNumber,
+           accountDigit: existUser.accountDigit,
+           wallet: existUser.wallet
+       }, secret, {
+           subject: existUser.id,
+           expiresIn,
+       });
+ 
+       const { password, ...rest} = existUser
+        
+       return {rest, token}
+    }
+
+    async signup(user: UserSignUp) {
+        const userRepository = getRepository(User);
+
+        const existUser = await userRepository.findOne({where: {email: user.email}})
+
+        if(existUser){
+          throw new AppError('Já existe um usuário cadastrado com esse email', 401);
+        }
+
+        const userData = {
+            ...user,
+            wallet: 0,
+            accountNumber: Math.floor(Math.random() * 999999),
+            accountDigit: Math.floor(Math.random() * 99)
+        }
+
+        const userCreate =  await userRepository.save(userData);
+
+        const { secret, expiresIn } = authConfig.jwt;
+        
+        const token = sign({
+            firstName: user.firstName,
+            lastName: user.lastName,
+        }, secret, {
+            subject: userCreate.id,
+            expiresIn,
+        });
+  
+        
+        return {userCreate, token};
+     }
+}

src/routes/index.ts

@@ -0,0 +1,9 @@
+import { Router } from 'express';
+import useRouter from './user.routes';
+
+
+const routes = Router();
+
+routes.use('/user', useRouter);
+
+export default routes;

src/routes/user.routes.ts

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import UserController from '../resources/user/user.controllers';
+
+const useRouter = Router();
+const userController = new UserController();
+
+useRouter.post('/signin', userController.signin)
+useRouter.post('/signup', userController.signup)
+
+export default useRouter;

src/shared/error/AppError.ts

@@ -0,0 +1,14 @@
+
+class AppError {
+    public readonly message: string;
+    public readonly statusCode: number;
+    public readonly data?: any
+
+    constructor(message: string, statusCode = 400, data?: any) {
+        this.message = message;
+        this.statusCode = statusCode;
+        this.data = data;
+    }
+}
+
+export default AppError;

tsconfig.json

@@ -5,6 +5,11 @@
       "rootDir": "./src",
       "outDir": "./build",
       "esModuleInterop": true,
-      "strict": true
+      "moduleResolution": "node",
+      "noImplicitReturns": false,
+      "strict": true,
+      "emitDecoratorMetadata": true,
+      "strictPropertyInitialization": false,
+      "experimentalDecorators": true
     }
-  }
+}