api: migrate to service + schemas and ditch user model

finally, it was such a fucking mess

Pedro Lucas Porcellis porcellis@eletrotupi.com 1 month ago 23c0d375c6007bb31f664fa3b208e18023c04ba7

Parents: df2ccb0

4 file(s) changed

api/src/controllers/users.ts +25 -36
api/src/models/user.ts +0 -146
api/src/schemas/user.schema.ts +6 -8
api/src/services/user.service.ts +34 -1

api/src/controllers/users.ts

@@ -1,22 +1,19 @@
    import { Request, Response, NextFunction } from 'express';
    import {
  -   findUserById,
  -   findUserByEmail,
  -   updateUser,
      generateToken
  - } from '@app/models/user';
  - 
  - import {
  -   validateRequiredFields
  - } from '@app/utils/validators'
  + } from '@app/services/auth.service';
    
    import { getQueue, MailJobName } from '@app/lib/queue';
    import {
  -   CreateUserSchema
  +   CreateUserSchema,
  +   UpdateUserSchema
    } from '@app/schemas';
    
    import {
  -   createUser
  +   createUser,
  +   findUserById,
  +   findUserByEmail,
  +   updateUser
    } from '@app/services/user.service';
    
    export const UsersController = {

@@ -46,37 +43,29 @@ },
    
      update: async (req: Request, res: Response, next: NextFunction) => {
        try {
  -       const { id } = req.params
  -       const { user: userParams } = req.body;
  +       const { id } = req.params;
    
  -       if (userParams) {
  -         const { email, password, firstName, lastName } = userParams;
  +       const parsed = UpdateUserSchema.safeParse(req.body);
  +       if (!parsed.success) {
  +         return res.status(400).json({
  +           errors: parsed.error!.issues
  +         });
  +       }
    
  -         const user = await findUserById(Number(id));
  +       const user = await findUserById(Number(id));
    
  -         if (!user) {
  -           return res.status(404).json({
  -             error: "Usuário não encontrado"
  -           })
  -         }
  +       if (!user) {
  +         return res.status(404).json({
  +           error: "Usuário não encontrado"
  +         });
  +       }
    
  -         if (email || password || firstName || lastName) {
  -           const response = await updateUser(user, {
  -             email, firstName, lastName, password
  -           })
  - 
  -           const updated = await findUserById(Number(id))
  +       const updated = await updateUser(parsed.data);
    
  -           // TODO: Drop encrypted password & token here
  -           return res.status(200).json({
  -             user: updated
  -           })
  -         } else {
  -           return res.status(200).json({
  -             user
  -           })
  -         }
  -       }
  +       // TODO: Drop encrypted password & token here
  +       return res.status(200).json({
  +         user: updated
  +       });
        } catch (err) {
          next(err);
        }

@@ -1,146 +0,0 @@
  - import bcrypt from "bcryptjs";
  - import { prisma } from '../lib/prisma'
  - import {
  -   generateToken as createJWT,
  -   generatePasswordResetToken,
  -   getPasswordResetExpiration,
  -   isTokenExpired
  - } from '@app/lib/jwt';
  - 
  - import {
  -   isValidEmail,
  -   isValidPassword,
  -   sanitizeString,
  -   validateRequiredFields
  - } from "@app/utils/validators";
  - 
  - import { InvalidEmailError, ShortPasswordError } from '@app/lib/errors/UserErrors'
  - 
  - type UserOptions = {
  -   email: string;
  -   firstName: string;
  -   lastName: string;
  -   password?: string;
  -   encryptedPassword?: string;
  - };
  - 
  - const generateToken = (userId: number, email: string) => {
  -   return createJWT(userId, email);
  - }
  - 
  - const findUserById = async (id: number) => {
  -   return await prisma.user.findUnique({
  -     where: { id }
  -   });
  - };
  - 
  - const findUserByEmail = async (email: string) => {
  -   return await prisma.user.findUnique({
  -     where: { email }
  -   });
  - };
  - 
  - const authenticateUser = async (email: string, password: string) => {
  -   const user = await findUserByEmail(email);
  - 
  -   if (!user) {
  -     throw new Error('Invalid credentials');
  -   }
  - 
  -   const isPasswordValid = bcrypt.compareSync(password, user.encryptedPassword);
  - 
  -   if (!isPasswordValid) {
  -     throw new Error('Invalid credentials');
  -   }
  - 
  -   return user;
  - };
  - 
  - const initiatePasswordReset = async (email: string) => {
  -   const user = await findUserByEmail(email);
  - 
  -   if (!user) {
  -     // Don't reveal whether email exists
  -     return { success: true };
  -   }
  - 
  -   const resetToken = generatePasswordResetToken();
  -   const resetExpires = getPasswordResetExpiration();
  - 
  -   await prisma.user.update({
  -     where: { id: user.id },
  -     data: {
  -       passwordResetToken: resetToken,
  -       passwordResetExpires: resetExpires
  -     }
  -   });
  - 
  -   // In production, send email with reset link
  -   // For now, return token for testing
  -   return {
  -     success: true,
  -     token: resetToken,
  -     email: user.email,
  -     id: user.id
  -   };
  - };
  - 
  - const resetPassword = async (token: string, newPassword: string) => {
  -   const user = await prisma.user.findFirst({
  -     where: {
  -       passwordResetToken: token,
  -       passwordResetExpires: { not: null }
  -     }
  -   });
  - 
  -   if (!user || !user.passwordResetExpires) {
  -     throw new Error('Invalid or expired reset token');
  -   }
  - 
  -   if (isTokenExpired(user.passwordResetExpires)) {
  -     throw new Error('Reset token has expired');
  -   }
  - 
  -   if (!isValidPassword(newPassword)) {
  -     throw new ShortPasswordError();
  -   }
  - 
  -   const encryptedPassword = bcrypt.hashSync(newPassword, 10);
  - 
  -   await prisma.user.update({
  -     where: { id: user.id },
  -     data: {
  -       encryptedPassword,
  -       passwordResetToken: null,
  -       passwordResetExpires: null
  -     }
  -   });
  - 
  -   return { success: true };
  - };
  - 
  - const updateUser = async (user: any, data: UserOptions) => {
  -   const { password } = data;
  - 
  -   if (password) {
  -     const encryptedPassword = bcrypt.hashSync(password, 10);
  - 
  -     delete data.password;
  -     data = { ...data, encryptedPassword }
  -   }
  - 
  -   return await prisma.user.update({
  -     where: { id: user.id },
  -     data
  -   });
  - }
  - 
  - export {
  -   findUserById,
  -   generateToken,
  -   findUserByEmail,
  -   authenticateUser,
  -   initiatePasswordReset,
  -   resetPassword,
  -   updateUser
  - }

api/src/schemas/user.schema.ts

@@ -7,13 +7,11 @@ email: z.string().email(),
      password: z.string().min(6)
    });
    
  - export type CreateUserInput = z.infer<typeof CreateUserSchema>;
  - 
  - export const UpdateUserSchema = z.object({
  -   firstName: z.string(),
  -   lastName: z.string().optional(),
  -   email: z.string().email(),
  -   password: z.string().min(6)
  - });
  + export const UpdateUserSchema = CreateUserSchema
  +   .partial()
  +   .extend({
  +     id: z.number()
  +   });
    
  + export type CreateUserInput = z.infer<typeof CreateUserSchema>;
    export type UpdateUserInput = z.infer<typeof UpdateUserSchema>;

api/src/services/user.service.ts

@@ -3,7 +3,8 @@ import { User } from '@prisma/client';
    import bcrypt from 'bcryptjs';
    
    import {
  -   CreateUserInput
  +   CreateUserInput,
  +   UpdateUserInput,
    } from "@app/schemas";
    
    export const createUser = async(input: CreateUserInput): Promise<User> => {

@@ -14,5 +15,37 @@ return await prisma.user.create({
        data: {
          ...data, encryptedPassword
        }
  +   })
  + };
  + 
  + export const findUserById = async(id: number): Promise<User | null> => {
  +   return await prisma.user.findUnique({
  +     where: {
  +       id
  +     }
  +   });
  + };
  + 
  + export const findUserByEmail = async(email: string): Promise<User | null> => {
  +   return await prisma.user.findUnique({
  +     where: {
  +       email
  +     }
  +   });
  + };
  + 
  + export const updateUser = async (input: UpdateUserInput): Promise<User> => {
  +   const { password, ...data } = input;
  + 
  +   const updateData = {
  +     ...data,
  +     ...(password && { encryptedPassword: bcrypt.hashSync(password, 10) })
  +   };
  + 
  +   return await prisma.user.update({
  +     where: {
  +       id: input.id
  +     },
  +     data: updateData
      })
    }