cd-aichat 1.0.0

package/src/utils/validation.js

@@ -0,0 +1,249 @@
+/**
+ * Validation Utilities
+ * Provides validation functions for chat features
+ */
+
+/**
+ * Validate message content
+ * @param {string} content - Message content
+ * @param {Object} options - Validation options
+ * @returns {Object} - Validation result
+ */
+export const validateMessageContent = (content, options = {}) => {
+  const {
+    minLength = 1,
+    maxLength = 10000,
+    allowEmpty = false
+  } = options;
+
+  const errors = [];
+
+  if (!content) {
+    if (!allowEmpty) {
+      errors.push('Message content cannot be empty');
+    }
+    return { valid: allowEmpty, errors };
+  }
+
+  const trimmed = content.trim();
+
+  if (trimmed.length === 0 && !allowEmpty) {
+    errors.push('Message content cannot be only whitespace');
+  }
+
+  if (trimmed.length < minLength) {
+    errors.push(`Message content must be at least ${minLength} characters`);
+  }
+
+  if (trimmed.length > maxLength) {
+    errors.push(`Message content cannot exceed ${maxLength} characters`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+/**
+ * Validate template data
+ * @param {Object} template - Template object
+ * @returns {Object} - Validation result
+ */
+export const validateTemplate = (template) => {
+  const errors = [];
+
+  if (!template) {
+    errors.push('Template is required');
+    return { valid: false, errors };
+  }
+
+  // Validate name
+  if (!template.name || template.name.trim().length === 0) {
+    errors.push('Template name cannot be empty');
+  } else if (template.name.length > 100) {
+    errors.push('Template name cannot exceed 100 characters');
+  }
+
+  // Validate content
+  if (!template.content || template.content.trim().length === 0) {
+    errors.push('Template content cannot be empty');
+  } else if (template.content.length > 5000) {
+    errors.push('Template content cannot exceed 5000 characters');
+  }
+
+  // Validate category
+  const validCategories = ['greeting', 'work', 'service', 'personal'];
+  if (template.category && !validCategories.includes(template.category)) {
+    errors.push(`Invalid template category: ${template.category}`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+/**
+ * Validate scheduled time
+ * @param {number|Date|string} time - Scheduled time
+ * @param {Object} options - Validation options
+ * @returns {Object} - Validation result
+ */
+export const validateScheduledTime = (time, options = {}) => {
+  const {
+    minDelay = 60000, // 1 minute
+    maxDelay = 7 * 24 * 60 * 60 * 1000 // 7 days
+  } = options;
+
+  const errors = [];
+
+  if (!time) {
+    errors.push('Scheduled time is required');
+    return { valid: false, errors };
+  }
+
+  const scheduledTime = new Date(time).getTime();
+  const now = Date.now();
+
+  if (isNaN(scheduledTime)) {
+    errors.push('Invalid scheduled time format');
+  } else if (scheduledTime <= now) {
+    errors.push('Scheduled time must be in the future');
+  } else if (scheduledTime - now < minDelay) {
+    errors.push(`Scheduled time must be at least ${minDelay / 60000} minutes in the future`);
+  } else if (scheduledTime - now > maxDelay) {
+    errors.push(`Scheduled time cannot exceed ${maxDelay / (24 * 60 * 60 * 1000)} days in the future`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+/**
+ * Validate burn after read delay
+ * @param {number} delay - Delay in seconds
+ * @returns {Object} - Validation result
+ */
+export const validateBurnDelay = (delay) => {
+  const errors = [];
+
+  if (typeof delay !== 'number' || delay < 0) {
+    errors.push('Burn delay must be a positive number');
+  } else if (delay < 1) {
+    errors.push('Burn delay must be at least 1 second');
+  } else if (delay > 3600) {
+    errors.push('Burn delay cannot exceed 1 hour');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+/**
+ * Sanitize content by removing HTML tags
+ * @param {string} content - Content to sanitize
+ * @returns {string} - Sanitized content
+ */
+export const sanitizeContent = (content) => {
+  if (!content) return '';
+  return content.replace(/<[^>]*>/g, '');
+};
+
+/**
+ * Escape HTML special characters
+ * @param {string} text - Text to escape
+ * @returns {string} - Escaped text
+ */
+export const escapeHtml = (text) => {
+  if (!text) return '';
+  const map = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#039;'
+  };
+  return text.replace(/[&<>"']/g, char => map[char]);
+};
+
+/**
+ * Validate email address
+ * @param {string} email - Email address
+ * @returns {boolean} - Validation result
+ */
+export const validateEmail = (email) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+};
+
+/**
+ * Validate URL
+ * @param {string} url - URL to validate
+ * @returns {boolean} - Validation result
+ */
+export const validateUrl = (url) => {
+  try {
+    new URL(url);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * Validate phone number (basic)
+ * @param {string} phone - Phone number
+ * @returns {boolean} - Validation result
+ */
+export const validatePhone = (phone) => {
+  const phoneRegex = /^[\d\s\-\+\(\)]+$/;
+  return phoneRegex.test(phone) && phone.replace(/\D/g, '').length >= 10;
+};
+
+/**
+ * Validate file size
+ * @param {number} size - File size in bytes
+ * @param {number} maxSize - Maximum size in bytes
+ * @returns {Object} - Validation result
+ */
+export const validateFileSize = (size, maxSize = 100 * 1024 * 1024) => {
+  const errors = [];
+
+  if (size > maxSize) {
+    errors.push(`File size exceeds maximum limit of ${maxSize / (1024 * 1024)}MB`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+/**
+ * Validate file type
+ * @param {string} filename - File name
+ * @param {string[]} allowedTypes - Allowed file extensions
+ * @returns {Object} - Validation result
+ */
+export const validateFileType = (filename, allowedTypes = []) => {
+  const errors = [];
+
+  if (allowedTypes.length === 0) {
+    return { valid: true, errors };
+  }
+
+  const ext = filename.split('.').pop().toLowerCase();
+  if (!allowedTypes.includes(ext)) {
+    errors.push(`File type .${ext} is not allowed`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};