api: move auth to service + schemas

It does look way better, now that I'm getting the hang of it

Pedro Lucas Porcellis porcellis@eletrotupi.com 1 month ago c50ef5d75b90563a411d2101772aeb3b363609ef

Parents: 766a1ea

4 file(s) changed

api/src/controllers/auth.ts +31 -55
api/src/schemas/auth.schema.ts +19 -0
api/src/schemas/index.ts +12 -4
api/src/services/auth.service.ts +103 -0

api/src/controllers/auth.ts

@@ -1,46 +1,41 @@
    import { Request, Response, NextFunction } from 'express';
    import {
  -   authenticateUser,
  +   login,
      generateToken,
  -   initiatePasswordReset,
  +   requestPasswordReset,
      resetPassword,
  -   findUserByEmail
  - } from '@app/models/user';
  + } from '@app/services/auth.service';
    
    import {
  -   validateRequiredFields
  - } from '@app/utils/validators';
  +   verifyToken
  + } from '@app/lib/jwt';
    
  - import { verifyToken } from '@app/lib/jwt';
  - import { getQueue, MailJobName } from '@app/lib/queue';
  + import {
  +   findUserByEmail
  + } from '@app/services/user.service'
  + 
  + import {
  +   LoginSchema,
  +   PasswordResetSchema,
  +   PasswordResetRequestSchema
  + } from '@app/schemas';
    
    export const AuthController = {
      login: async (req: Request, res: Response, next: NextFunction) => {
        try {
  -       const { email, password } = req.body;
  +       const parsed = LoginSchema.safeParse(req.body);
    
  -       const requiredValidation = validateRequiredFields(req.body, [
  -         'email', 'password'
  -       ]);
  - 
  -       if (!requiredValidation.valid) {
  +       if (!parsed.success) {
            return res.status(400).json({
  -           error: 'Missing required fields',
  -           missing: requiredValidation.missing
  +           errors: parsed.error!.issues
            });
          }
    
  -       const user = await authenticateUser(email, password);
  -       const jwtToken = generateToken(user.id, user.email);
  +       const { user, token } = await login(parsed.data);
    
  -       res.json({
  -         token: jwtToken,
  -         user: {
  -           id: user.id,
  -           email: user.email,
  -           firstName: user.firstName,
  -           lastName: user.lastName
  -         }
  +       return res.json({
  +         token,
  +         user
          });
        } catch (err: any) {
          if (err.message === 'Invalid credentials') {

@@ -52,30 +47,17 @@ },
    
      forgotPassword: async (req: Request, res: Response, next: NextFunction) => {
        try {
  -       const { email } = req.body;
    
  -       const requiredValidation = validateRequiredFields(req.body, ['email']);
  +       const parsed = PasswordResetRequestSchema.safeParse(req.body);
    
  -       if (!requiredValidation.valid) {
  +       if (!parsed.success) {
            return res.status(400).json({
  -           error: 'Email is required',
  -           missing: requiredValidation.missing
  +           errors: parsed.error!.issues
            });
          }
    
  -       const result = await initiatePasswordReset(email);
  -       const mailQueue = getQueue('mail');
  -       const job = await mailQueue.add(MailJobName.PasswordReset, {
  -         userId: result.id,
  -         token: result.token
  -       });
  - 
  -       // In production, don't send token in response
  -       // Instead, send email with reset link
  -       res.json({
  -         message: 'Password reset instructions sent to your email',
  -         ...(!process.env.NODE_ENV || process.env.NODE_ENV === 'development' ? { token: result.token } : {})
  -       });
  +       const result = await requestPasswordReset(parsed.data);
  +       return res.status(200).json(result)
        } catch (err) {
          next(err);
        }

@@ -83,22 +65,16 @@ },
    
      resetPassword: async (req: Request, res: Response, next: NextFunction) => {
        try {
  -       const { token, password } = req.body;
  +       const parsed = PasswordResetSchema.safeParse(req.body);
    
  -       const requiredValidation = validateRequiredFields(req.body, [
  -         'token', 'password'
  -       ]);
  - 
  -       if (!requiredValidation.valid) {
  +       if (!parsed.success) {
            return res.status(400).json({
  -           error: 'Missing required fields',
  -           missing: requiredValidation.missing
  +           errors: parsed.error!.issues
            });
          }
    
  -       await resetPassword(token, password);
  - 
  -       res.json({ message: 'Password successfully reset' });
  +       const result = await resetPassword(parsed.data);
  +       return res.status(200).json(result);
        } catch (err: any) {
          if (err.message.includes('token')) {
            return res.status(400).json({ error: err.message });

api/src/schemas/auth.schema.ts

@@ -0,0 +1,19 @@
  + import { z } from 'zod';
  + 
  + export const LoginSchema = z.object({
  +   email: z.string().email(),
  +   password: z.string().min(1)
  + });
  + 
  + export const PasswordResetRequestSchema = z.object({
  +   email: z.string().email()
  + });
  + 
  + export const PasswordResetSchema = z.object({
  +   token: z.string(),
  +   newPassword: z.string().min(8)
  + })
  + 
  + export type LoginInput = z.infer<typeof LoginSchema>;
  + export type PasswordResetRequestInput = z.infer<typeof PasswordResetRequestSchema>;
  + export type PasswordResetInput = z.infer<typeof PasswordResetSchema>;

api/src/schemas/index.ts

@@ -8,9 +8,17 @@ CreateMoodInput
    } from '@app/schemas/mood.schema';
    
    export {
  -   CreateUserSchema
  +   CreateUserSchema,
  +   UpdateUserSchema,
  +   type CreateUserInput,
  +   type UpdateUserInput,
    } from '@app/schemas/user.schema';
    
  - export type {
  -   CreateUserInput
  - } from '@app/schemas/user.schema';
  + export {
  +   LoginSchema,
  +   PasswordResetRequestSchema,
  +   PasswordResetSchema,
  +   type LoginInput,
  +   type PasswordResetRequestInput,
  +   type PasswordResetInput
  + } from '@app/schemas/auth.schema';

api/src/services/auth.service.ts

@@ -0,0 +1,103 @@
  + import { prisma } from '@app/lib/prisma';
  + import bcrypt from "bcryptjs";
  + 
  + import {
  +   generateToken as createJWT,
  +   generatePasswordResetToken,
  +   getPasswordResetExpiration,
  +   isTokenExpired
  + } from '@app/lib/jwt';
  + 
  + import {
  +   findUserByEmail
  + } from '@app/services/user.service'; // Replace with a barrel import
  + 
  + import {
  +   LoginInput,
  +   PasswordResetRequestInput,
  +   PasswordResetInput
  + } from '@app/schemas'
  + 
  + import { getQueue, MailJobName } from '@app/lib/queue';
  + 
  + class InvalidCredentialsError extends Error {
  +   constructor() { super('Invalid credentials') }
  + }
  + 
  + class InvalidOrExpiredTokenError extends Error {
  +   constructor() { super('Invalid or Expired reset token') }
  + }
  + 
  + export const login = async({ email, password }: LoginInput) => {
  +   const user = await findUserByEmail(email);
  + 
  +   if (!user || !bcrypt.compareSync(password, user.encryptedPassword)) {
  +     throw new InvalidCredentialsError();
  +   }
  + 
  +   const token = generateToken(user.id, user.email);
  + 
  +   return { user, token };
  + };
  + 
  + export const requestPasswordReset = async ({ email }: PasswordResetRequestInput) => {
  +   const user = await findUserByEmail(email);
  + 
  +   if (!user) {
  +     return { success: true };
  +   }
  + 
  +   const resetToken = generatePasswordResetToken();
  +   const resetExpires = getPasswordResetExpiration();
  + 
  +   await prisma.user.update({
  +     where: {
  +       id: user.id
  +     },
  +     data: {
  +       passwordResetToken: resetToken,
  +       passwordResetExpires: resetExpires
  +     }
  +   });
  + 
  +   const mailQueue = getQueue('mail');
  +   const job = await mailQueue.add(MailJobName.PasswordReset, {
  +     userId: user.id,
  +     token: resetToken
  +   });
  + 
  +   return {
  +     success: true,
  +     token: resetToken
  +   };
  + };
  + 
  + export const resetPassword = async ({ token, newPassword }: PasswordResetInput) => {
  +   const user = await prisma.user.findFirst({
  +     where: {
  +       passwordResetToken: token,
  +       passwordResetExpires: { not: null }
  +     }
  +   });
  + 
  +   if (!user || !user.passwordResetExpires || isTokenExpired(user.passwordResetExpires)) {
  +     throw new InvalidOrExpiredTokenError();
  +   }
  + 
  +   await prisma.user.update({
  +     where: { id: user.id },
  +     data: {
  +       encryptedPassword: bcrypt.hashSync(newPassword, 10),
  +       passwordResetToken: null,
  +       passwordResetExpires: null
  +     }
  +   });
  + 
  +   return {
  +     success: true
  +   };
  + };
  + 
  + export const generateToken = (userId: number, email: string) => {
  +   return createJWT(userId, email);
  + };