api/utils: add some validations for mood, user and mood/emotion components

Pedro Lucas Porcellis porcellis@eletrotupi.com 6 months ago 06314a5b665164bc343bc1c0a38ca4a562c53b7b

Parents: f850d20

2 file(s) changed

api/src/utils/emotions.js +102 -0
api/src/utils/validators.js +96 -0

api/src/utils/emotions.js

@@ -0,0 +1,102 @@
  + // Emotion types enum
  + export const Emotions = {
  +   JOY: 'joy',
  +   TRUST: 'trust',
  +   FEAR: 'fear',
  +   SURPRISE: 'surprise',
  +   SAD: 'sad',
  +   DISGUST: 'disgust',
  +   ANGRY: 'angry',
  +   ANXIETY: 'anxiety'
  + };
  + 
  + // Valid emotion values for validation
  + export const VALID_EMOTIONS = Object.values(Emotions);
  + 
  + // Validate emotion type
  + export function isValidEmotion(emotion) {
  +   return VALID_EMOTIONS.includes(emotion?.toLowerCase());
  + }
  + 
  + // Validate intensity value
  + export function isValidIntensity(intensity) {
  +   const num = Number(intensity);
  +   return !isNaN(num) && num >= 1 && num <= 10;
  + }
  + 
  + // Validate rating value
  + export function isValidRating(rating) {
  +   const num = Number(rating);
  +   return !isNaN(num) && num >= 1 && num <= 10;
  + }
  + 
  + // Validate level values (stress, anxiety, energy)
  + export function isValidLevel(level) {
  +   const num = Number(level);
  +   return !isNaN(num) && num >= 1 && num <= 10;
  + }
  + 
  + // Validate mood components array
  + export function validateMoodComponents(components) {
  +   if (!Array.isArray(components)) {
  +     return { valid: false, error: 'Components must be an array' };
  +   }
  + 
  +   const emotions = new Set();
  + 
  +   for (const component of components) {
  +     if (!Object.hasOwn(component, 'emotion') || !Object.hasOwn(component, 'intensity')) {
  +       return { valid: false, error: 'Each component must have emotion and intensity' };
  +     }
  + 
  +     const emotionLower = component.emotion.toLowerCase();
  + 
  +     if (!isValidEmotion(emotionLower)) {
  +       return { valid: false, error: `Invalid emotion: ${component.emotion}` };
  +     }
  + 
  +     if (!isValidIntensity(component.intensity)) {
  +       return { valid: false, error: `Invalid intensity for ${component.emotion}: must be 1-10` };
  +     }
  + 
  +     if (emotions.has(emotionLower)) {
  +       return { valid: false, error: `Duplicate emotion: ${component.emotion}` };
  +     }
  + 
  +     emotions.add(emotionLower);
  +   }
  + 
  +   return { valid: true };
  + }
  + 
  + // Get emotion statistics
  + export function calculateEmotionStats(moodComponents) {
  +   const stats = {
  +     dominant: null,
  +     average: 0,
  +     breakdown: {}
  +   };
  + 
  +   if (!moodComponents || moodComponents.length === 0) {
  +     return stats;
  +   }
  + 
  +   let maxIntensity = 0;
  +   let totalIntensity = 0;
  + 
  +   moodComponents.forEach(component => {
  +     const intensity = Number(component.intensity);
  +     totalIntensity += intensity;
  + 
  +     stats.breakdown[component.emotion] = intensity;
  + 
  +     if (intensity > maxIntensity) {
  +       maxIntensity = intensity;
  +       stats.dominant = component.emotion;
  +     }
  +   });
  + 
  +   stats.average = totalIntensity / moodComponents.length;
  + 
  +   return stats;
  + }

api/src/utils/validators.js

@@ -0,0 +1,97 @@
  + // Email validation
  + export function isValidEmail(email) {
  +   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  +   return emailRegex.test(email);
  + }
  + 
  + // Password validation (minimum 6 characters)
  + export function isValidPassword(password) {
  +   return password && password.length >= 6;
  + }
  + 
  + import { parseISO, isValid, isFuture, isAfter } from 'date-fns';
  + 
  + // Date validation
  + export function isValidDate(dateString) {
  +   if (!dateString) return false;
  +   try {
  +     const date = parseISO(dateString);
  +     return isValid(date);
  +   } catch {
  +     return false;
  +   }
  + }
  + 
  + // Check if date is not in the future
  + export function isNotFutureDate(dateString) {
  +   if (!dateString) return false;
  +   try {
  +     const date = parseISO(dateString);
  +     return isValid(date) && !isFuture(date);
  +   } catch {
  +     return false;
  +   }
  + }
  + 
  + // Validate date range
  + export function isValidDateRange(startDate, endDate) {
  +   if (!startDate || !endDate) return false;
  +   try {
  +     const start = parseISO(startDate);
  +     const end = parseISO(endDate);
  + 
  +     if (!isValid(start) || !isValid(end)) {
  +       return false;
  +     }
  + 
  +     return !isAfter(start, end);
  +   } catch {
  +     return false;
  +   }
  + }
  + 
  + // Sanitize string input
  + export function sanitizeString(str) {
  +   if (typeof str !== 'string') return '';
  +   return str.trim().slice(0, 500); // Limit to 500 chars
  + }
  + 
  + // Validate required fields
  + export function validateRequiredFields(data, fields) {
  +   const missing = [];
  + 
  +   for (const field of fields) {
  +     if (data[field] === undefined || data[field] === null || data[field] === '') {
  +       missing.push(field);
  +     }
  +   }
  + 
  +   return {
  +     valid: missing.length === 0,
  +     missing
  +   };
  + }
  + 
  + // Validate number in range
  + export function isInRange(value, min, max) {
  +   const num = Number(value);
  +   return !isNaN(num) && num >= min && num <= max;
  + }
  + 
  + // Parse and validate integer
  + export function parseIntOrDefault(value, defaultValue = null) {
  +   const parsed = parseInt(value, 10);
  +   return isNaN(parsed) ? defaultValue : parsed;
  + }
  + 
  + // Validate pagination parameters
  + export function validatePagination(page, limit) {
  +   const validPage = Math.max(1, parseIntOrDefault(page, 1));
  +   const validLimit = Math.min(100, Math.max(1, parseIntOrDefault(limit, 20)));
  + 
  +   return {
  +     page: validPage,
  +     limit: validLimit,
  +     offset: (validPage - 1) * validLimit
  +   };
  + }