// errorHandler.js
class AppError extends Error {
constructor(message, statusCode) {
  super(message);
  this.statusCode = statusCode;
  this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
  this.isOperational = true;

  Error.captureStackTrace(this, this.constructor);
}
}

// Middleware de manejo de errores global
const globalErrorHandler = (err, req, res, next) => {
err.statusCode = err.statusCode || 500;
err.status = err.status || 'error';

res.status(err.statusCode).json({
  status: err.status,
  message: err.message,
  ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
});
};

module.exports = { AppError, globalErrorHandler };

// catchAsync.js - Manejo de errores asíncronos
const catchAsync = (fn) => {
return (req, res, next) => {
  fn(req, res, next).catch(next);
};
};

// Ejemplo de uso
const getUsers = catchAsync(async (req, res, next) => {
const users = await User.find();

if (!users.length) {
  return next(new AppError('No users found', 404));
}

res.status(200).json({
  status: 'success',
  results: users.length,
  data: { users }
});
});

// validationMiddleware.js
const { body, validationResult } = require('express-validator');

const validate = (validations) => {
return async (req, res, next) => {
  for (let validation of validations) {
    const result = await validation.run(req);
    if (result.errors.length) break;
  }

  const errors = validationResult(req);
  if (errors.isEmpty()) {
    return next();
  }

  return res.status(400).json({
    errors: errors.array()
  });
};
};

// Ejemplo de uso
app.post('/usuarios', 
validate([
  body('email').isEmail().withMessage('Email inválido'),
  body('nombre').notEmpty().withMessage('Nombre requerido')
]),
crearUsuario
);

const winston = require('winston');

const logger = winston.createLogger({
level: 'error',
format: winston.format.combine(
  winston.format.timestamp(),
  winston.format.json()
),
transports: [
  new winston.transports.File({ filename: 'error.log' })
]
});

// Middleware de registro
const errorLogger = (err, req, res, next) => {
logger.error({
  message: err.message,
  stack: err.stack,
  method: req.method,
  path: req.path
});
next(err);
};