Node

Microserviço para Autenticação e Gerenciamento de Usuários - REST API

CRUD de Usuários com Promises

O acesso e consultas ao banco de dados serão realizadas via Promises (Objeto que representa uma tarefa assíncrona).
Arquivo src/repositories/user.repository.ts

Promise do endpoint GET /users

Listar todos os usuários.


                        import db from "../db";
                        import User from "../models/user.model";

                        class userRepository {

                            async allUsers(): Promise<User[]> {
                                const query = `SELECT uuid, userName FROM users`; 
                                const { rows } = await db.query<User>(query); 
                                return rows || [];
                            }
                        }

                        export default new userRepository();
                    

Promise do endpoint GET /users/:uuid

Listar um usuário especifico filtrando pelo UUID.


                        import db from "../db";
                        import User from "../models/user.model";

                        class userRepository {

                            async byIdUser(uuid: string): Promise<User> {
                                const query = `SELECT uuid, userName FROM users WHERE uuid = $1`; 

                                const values = [uuid]; 
                                const { rows } = await db.query<User>(query, values); 
                                const [user] = rows;  
                        
                                return user; 
                            }
                        }
                        export default new userRepository();
                    

Promise do endpoint POST /users

Criar um usuário e retorna o ID.


                        import db from "../db";
                        import User from "../models/user.model";

                        class userRepository {
                            async createUser(user: User): Promise<string> {
                                //  (Boa Prática)
                                const script = `INSERT INTO users (userName, userPassword) VALUES ($1, crypt($2, 'my_salt')) RETURNING uuid`;
                                const values = [user.userName, user.userPassword]; 
                                const { rows } = await db.query<{ uuid: string }>(script, values); 
                                const [newUser] = rows; 
                                return newUser.uuid;
                            }
                        }
                        export default new userRepository();
                    
Boa Prática: Transformar 'my_salt' que é uma chave privada em uma variável de ambiente.

Promise do endpoint PUT /users/:uuid

Atualizar um usuário especifico filtrando pelo UUID. Void, sem retorno.


                        import db from "../db";
                        import User from "../models/user.model";

                        class userRepository {
                            async updateUser(user: User): Promise {
                                const script = `UPDATE users SET userName = $1, userPassword = crypt($2, 'my_salt') WHERE uuid = $3`;
                                const values = [user.userName, user.userPassword, user.uuid]; 
                                await db.query(script, values);
                            }
                        }
                        export default new userRepository();
                    

Promise do endpoint DELETE /users/:uuid

Excluir um usuário especifico filtrando pelo UUID. Void, sem retorno.


                        import db from "../db";
                        import User from "../models/user.model";

                        class userRepository {
                            async deleteUser(uuid: string): Promise {
                                const script = `DELETE FROM users WHERE uuid = $1`;
                                const values = [uuid];
                                await db.query(script, values);
                            }
                        }
                        export default new userRepository();
                    

Refatoração do CRUD de usuários para chamar as Promises

Arquivo src/routes/users.route.ts


                        import { Router, Request, Response, NextFunction } from 'express';
                        import { StatusCodes } from 'http-status-codes';
                        import userRepository from '../repositories/user.repository';
                        
                        const usersRoute = Router();

                        // Listar todos os usuários
                        usersRoute.get('/users', async (req: Request, res: Response, next: NextFunction) => {
                            const users = await userRepository.allUsers();
                            res.status(StatusCodes.OK).json(users); 
                        });
                        
                        // Listar um usuário especifico
                        usersRoute.get('/users/:uuid', async (req: Request<{uuid: string}>, res: Response, next: NextFunction) => {
                            const user = await userRepository.byIdUser(req.params.uuid);
                            res.status(StatusCodes.OK).json(user); 
                        });

                        // Criar um usuário, retorna o ID
                        usersRoute.post('/users', async (req: Request, res: Response, next: NextFunction) => {
                            const newUser = req.body;
                            const uuid = await userRepository.createUser(newUser);
                            res.status(StatusCodes.CREATED).send(uuid);
                        });

                        // Atualizar um usuário
                        usersRoute.put('/users/:uuid', async (req: Request<{ uuid: string }>, res: Response, next: NextFunction) => {
                            const uuid = req.params.uuid;
                            const modifiedUser = req.body;
                            modifiedUser.uuid = uuid;
                            await userRepository.updateUser(modifiedUser);
                            res.status(StatusCodes.OK).send(); 
                        });

                        // Excluir um usuário
                        usersRoute.delete('/users/:uuid', async (req: Request<{ uuid: string }>, res: Response, next: NextFunction) => {
                            const uuid = req.params.uuid;
                            await userRepository.deleteUser(uuid);
                            res.status(StatusCodes.OK).send(); 
                        });

                        export default usersRoute;