@jammysunshine/astrology-shared 1.0.1

package/validation/BaseValidator.js

@@ -0,0 +1,308 @@
+const { validateBirthData, createValidationError } = require('./index');
+
+const { getLogger } = require('../logger');
+
+/**
+ * Base Validator class for astrology services
+ * Provides common validation functionality and patterns
+ */
+class BaseValidator {
+  constructor() {
+    this.logger = getLogger('BaseValidator');
+  }
+
+
+
+
+
+  /**
+   * Validate required fields
+   * @param {Object} data - Data object
+   * @param {Array<string>} requiredFields - Required field names
+   * @returns {Object} Validation result
+   */
+  validateRequired(data, requiredFields) {
+    const errors = [];
+
+    for (const field of requiredFields) {
+      if (!data || !(field in data) || data[field] === null || data[field] === undefined) {
+        errors.push({
+          field,
+          message: `${field} is required`,
+          code: 'MISSING_REQUIRED_FIELD'
+        });
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Validate string fields with length constraints
+   * @param {Object} data - Data object
+   * @param {Object} fieldRules - Field validation rules {fieldName: {minLength, maxLength, pattern}}
+   * @returns {Object} Validation result
+   */
+  validateStringFields(data, fieldRules) {
+    const errors = [];
+
+    for (const [field, rules] of Object.entries(fieldRules)) {
+      const value = data[field];
+
+      if (value !== undefined && value !== null) {
+        if (typeof value !== 'string') {
+          errors.push({
+            field,
+            message: `${field} must be a string`,
+            code: 'INVALID_TYPE'
+          });
+          continue;
+        }
+
+        if (rules.minLength && value.length < rules.minLength) {
+          errors.push({
+            field,
+            message: `${field} must be at least ${rules.minLength} characters`,
+            code: 'TOO_SHORT'
+          });
+        }
+
+        if (rules.maxLength && value.length > rules.maxLength) {
+          errors.push({
+            field,
+            message: `${field} must be at most ${rules.maxLength} characters`,
+            code: 'TOO_LONG'
+          });
+        }
+
+        if (rules.pattern && !rules.pattern.test(value)) {
+          errors.push({
+            field,
+            message: `${field} format is invalid`,
+            code: 'INVALID_FORMAT'
+          });
+        }
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Validate numeric ranges
+   * @param {Object} data - Data object
+   * @param {Object} fieldRules - Field validation rules {fieldName: {min, max, integer}}
+   * @returns {Object} Validation result
+   */
+  validateNumericFields(data, fieldRules) {
+    const errors = [];
+
+    for (const [field, rules] of Object.entries(fieldRules)) {
+      const value = data[field];
+
+      if (value !== undefined && value !== null) {
+        if (typeof value !== 'number' || isNaN(value)) {
+          errors.push({
+            field,
+            message: `${field} must be a valid number`,
+            code: 'INVALID_NUMBER'
+          });
+          continue;
+        }
+
+        if (rules.integer && !Number.isInteger(value)) {
+          errors.push({
+            field,
+            message: `${field} must be an integer`,
+            code: 'NOT_INTEGER'
+          });
+        }
+
+        if (rules.min !== undefined && value < rules.min) {
+          errors.push({
+            field,
+            message: `${field} must be at least ${rules.min}`,
+            code: 'TOO_SMALL'
+          });
+        }
+
+        if (rules.max !== undefined && value > rules.max) {
+          errors.push({
+            field,
+            message: `${field} must be at most ${rules.max}`,
+            code: 'TOO_LARGE'
+          });
+        }
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Validate array fields
+   * @param {Object} data - Data object
+   * @param {Object} fieldRules - Field validation rules {fieldName: {minItems, maxItems, itemValidator}}
+   * @returns {Object} Validation result
+   */
+  validateArrayFields(data, fieldRules) {
+    const errors = [];
+
+    for (const [field, rules] of Object.entries(fieldRules)) {
+      const value = data[field];
+
+      if (value !== undefined && value !== null) {
+        if (!Array.isArray(value)) {
+          errors.push({
+            field,
+            message: `${field} must be an array`,
+            code: 'NOT_ARRAY'
+          });
+          continue;
+        }
+
+        if (rules.minItems && value.length < rules.minItems) {
+          errors.push({
+            field,
+            message: `${field} must have at least ${rules.minItems} items`,
+            code: 'TOO_FEW_ITEMS'
+          });
+        }
+
+        if (rules.maxItems && value.length > rules.maxItems) {
+          errors.push({
+            field,
+            message: `${field} must have at most ${rules.maxItems} items`,
+            code: 'TOO_MANY_ITEMS'
+          });
+        }
+
+        // Validate individual items if validator provided
+        if (rules.itemValidator && typeof rules.itemValidator === 'function') {
+          value.forEach((item, index) => {
+            try {
+              const itemResult = rules.itemValidator(item);
+              if (!itemResult.isValid) {
+                errors.push(...itemResult.errors.map(error => ({
+                  ...error,
+                  field: `${field}[${index}].${error.field}`
+                })));
+              }
+            } catch (error) {
+              errors.push({
+                field: `${field}[${index}]`,
+                message: error.message,
+                code: 'ITEM_VALIDATION_ERROR'
+              });
+            }
+          });
+        }
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Validate coordinates (latitude/longitude)
+   * @param {Object} coordinates - Coordinates object {latitude, longitude}
+   * @returns {Object} Validation result
+   */
+  validateCoordinates(coordinates) {
+    const errors = [];
+
+    if (!coordinates || typeof coordinates !== 'object') {
+      return {
+        isValid: false,
+        errors: [{
+          field: 'coordinates',
+          message: 'Coordinates object is required',
+          code: 'MISSING_COORDINATES'
+        }]
+      };
+    }
+
+    const { latitude, longitude } = coordinates;
+
+    if (latitude === undefined || latitude === null) {
+      errors.push({
+        field: 'coordinates.latitude',
+        message: 'Latitude is required',
+        code: 'MISSING_LATITUDE'
+      });
+    } else if (typeof latitude !== 'number' || isNaN(latitude)) {
+      errors.push({
+        field: 'coordinates.latitude',
+        message: 'Latitude must be a valid number',
+        code: 'INVALID_LATITUDE'
+      });
+    } else if (latitude < -90 || latitude > 90) {
+      errors.push({
+        field: 'coordinates.latitude',
+        message: 'Latitude must be between -90 and 90',
+        code: 'LATITUDE_OUT_OF_RANGE'
+      });
+    }
+
+    if (longitude === undefined || longitude === null) {
+      errors.push({
+        field: 'coordinates.longitude',
+        message: 'Longitude is required',
+        code: 'MISSING_LONGITUDE'
+      });
+    } else if (typeof longitude !== 'number' || isNaN(longitude)) {
+      errors.push({
+        field: 'coordinates.longitude',
+        message: 'Longitude must be a valid number',
+        code: 'INVALID_LONGITUDE'
+      });
+    } else if (longitude < -180 || longitude > 180) {
+      errors.push({
+        field: 'coordinates.longitude',
+        message: 'Longitude must be between -180 and 180',
+        code: 'LONGITUDE_OUT_OF_RANGE'
+      });
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+
+
+  /**
+   * Combine multiple validation results
+   * @param {Array<Object>} validationResults - Array of validation result objects
+   * @returns {Object} Combined validation result
+   */
+  combineValidations(validationResults) {
+    const allErrors = [];
+
+    for (const result of validationResults) {
+      if (!result.isValid && result.errors) {
+        allErrors.push(...result.errors);
+      }
+    }
+
+    return {
+      isValid: allErrors.length === 0,
+      errors: allErrors
+    };
+  }
+}
+
+module.exports = BaseValidator;

package/validation/index.js

@@ -0,0 +1,88 @@
+// This file is now refactored to use the AJV/JSON Schema system.
+
+const { isValid, parse } = require('date-fns'); // Keep date-fns for now if AJV patterns are not strict enough for parsing.
+const { validateInput, loadSchema } = require('../schemas'); // Import validateInput and loadSchema from central schema management
+
+/**
+ * Validate birth data with strict DD/MM/YYYY format using AJV.
+ * @param {Object} data - Input data to validate
+ * @returns {Object} Validated and sanitized data
+ * @throws {Error} If validation fails
+ */
+function validateBirthData(data) {
+  // Use the birthData component schema for validating just the birthData object
+  const schemaName = 'astrology/birthData';
+
+  const result = validateInput(schemaName, data); // Validate birthData directly
+
+  if (!result.isValid) {
+    const errorDetails = result.errors.map(d => d.message).join(', ');
+    throw createValidationError('VALIDATION_ERROR', `Invalid birth data: ${errorDetails}`, result.errors);
+  }
+
+  // If validation is successful, return the validated data (which may have defaults applied by AJV)
+  return result.data;
+}
+
+/**
+ * Create a standardized validation error
+ * @param {string} code - Error code
+ * @param {string} message - Error message
+ * @param {Object} details - Additional error details
+ * @returns {Error} Validation error
+ */
+function createValidationError(code, message, details = {}) {
+  const error = new Error(message);
+  error.code = code;
+  error.details = details;
+  error.type = 'VALIDATION_ERROR';
+  return error;
+}
+
+/**
+ * Validate client context for multi-frontend support using AJV.
+ * @param {Object} context - Client context
+ * @returns {Object} Validated context
+ */
+function validateClientContext(context) {
+  if (!context) return {};
+
+  const result = validateInput('client-context', context); // Validate against client-context schema
+
+  if (!result.isValid) {
+    const errorDetails = result.errors.map(d => d.message).join(', ');
+    throw createValidationError('INVALID_CLIENT_CONTEXT', `Invalid client context: ${errorDetails}`, result.errors);
+  }
+
+  // If validated, AJV might have applied defaults/coerced types.
+  // We still need to validate preferences separately if they are nested.
+  if (result.data.preferences) {
+      result.data.preferences = validatePreferences(result.data.preferences);
+  }
+
+  return result.data;
+}
+
+/**
+ * Validate user preferences using AJV.
+ * @param {Object} preferences - User preferences
+ * @returns {Object} Validated preferences
+ */
+function validatePreferences(preferences) {
+  const result = validateInput('preferences', preferences); // Validate against preferences schema
+
+  if (!result.isValid) {
+    const errorDetails = result.errors.map(d => d.message).join(', ');
+    throw createValidationError('INVALID_PREFERENCES', `Invalid user preferences: ${errorDetails}`, result.errors);
+  }
+
+  // If validated, AJV might have applied defaults/coerced types.
+  return result.data;
+}
+
+module.exports = {
+  validateBirthData,
+  validateClientContext,
+  validatePreferences,
+  createValidationError
+};