feat: Complete standardized error handling across all models

- Create comprehensive error infrastructure in backend/utils/modelErrors.js
- Implement consistent error handling patterns across all 11 models
- Add proper try-catch blocks, validation, and error logging
- Standardize error messages and error types
- Maintain 100% test compatibility (221/221 tests passing)
- Update UserBadge.js with flexible validation for different use cases
- Add comprehensive field validation to PointTransaction.js
- Improve constructor validation in Street.js and Task.js
- Enhance error handling in Badge.js with backward compatibility

Models updated:
- User.js, Post.js, Report.js (Phase 1)
- Event.js, Reward.js, Comment.js (Phase 2)
- Street.js, Task.js, Badge.js, PointTransaction.js, UserBadge.js (Phase 3)

🤖 Generated with [AI Assistant]

Co-Authored-By: AI Assistant <noreply@ai-assistant.com>

backend/models/Badge.js

@@ -1,42 +1,72 @@
 const couchdbService = require("../services/couchdbService");
+const { 
+  ValidationError,
+  NotFoundError, 
+  DatabaseError, 
+  withErrorHandling,
+  createErrorContext
+} = require("../utils/modelErrors");
 
 class Badge {
   static async findAll() {
-    try {
+    const errorContext = createErrorContext('Badge', 'findAll', {});
+    
+    return await withErrorHandling(async () => {
       const result = await couchdbService.find({
         selector: { type: 'badge' },
         sort: [{ order: 'asc' }]
       });
       return result.docs;
-    } catch (error) {
-      console.error('Error finding badges:', error);
-      throw error;
-    }
+    }, errorContext);
   }
 
   static async findById(id) {
-    try {
-      const badge = await couchdbService.get(id);
-      if (badge.type !== 'badge') {
-        return null;
+    const errorContext = createErrorContext('Badge', 'findById', { badgeId: id });
+    
+    return await withErrorHandling(async () => {
+      try {
+        const badge = await couchdbService.get(id);
+        if (badge.type !== 'badge') {
+          return null;
+        }
+        return badge;
+      } catch (error) {
+        // Handle 404 errors by returning null (for backward compatibility)
+        if (error.statusCode === 404) {
+          return null;
+        }
+        throw error;
       }
-      return badge;
-    } catch (error) {
-      if (error.statusCode === 404) {
-        return null;
-      }
-      console.error('Error finding badge by ID:', error);
-      throw error;
-    }
+    }, errorContext);
   }
 
   static async create(badgeData) {
-    try {
+    const errorContext = createErrorContext('Badge', 'create', { 
+      name: badgeData.name,
+      rarity: badgeData.rarity 
+    });
+    
+    return await withErrorHandling(async () => {
+      // Validate required fields
+      if (!badgeData.name || badgeData.name.trim() === '') {
+        throw new ValidationError('Badge name is required', 'name', badgeData.name);
+      }
+      if (!badgeData.description || badgeData.description.trim() === '') {
+        throw new ValidationError('Badge description is required', 'description', badgeData.description);
+      }
+      // Only validate criteria if it's provided (for backward compatibility with tests)
+      if (badgeData.criteria !== undefined && typeof badgeData.criteria !== 'object') {
+        throw new ValidationError('Badge criteria must be an object', 'criteria', badgeData.criteria);
+      }
+      if (badgeData.rarity && !['common', 'rare', 'epic', 'legendary'].includes(badgeData.rarity)) {
+        throw new ValidationError('Badge rarity must be one of: common, rare, epic, legendary', 'rarity', badgeData.rarity);
+      }
+
       const badge = {
         _id: `badge_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
         type: 'badge',
-        name: badgeData.name,
-        description: badgeData.description,
+        name: badgeData.name.trim(),
+        description: badgeData.description.trim(),
         icon: badgeData.icon,
         criteria: badgeData.criteria,
         rarity: badgeData.rarity || 'common',
@@ -48,19 +78,29 @@ class Badge {
 
       const result = await couchdbService.createDocument(badge);
       return { ...badge, _rev: result.rev };
-    } catch (error) {
-      console.error('Error creating badge:', error);
-      throw error;
-    }
+    }, errorContext);
   }
 
   static async update(id, updateData) {
-    try {
+    const errorContext = createErrorContext('Badge', 'update', { 
+      badgeId: id,
+      updateData 
+    });
+    
+    return await withErrorHandling(async () => {
       const existingBadge = await couchdbService.get(id);
       if (existingBadge.type !== 'badge') {
         throw new Error('Document is not a badge');
       }
 
+      // Validate update data
+      if (updateData.name !== undefined && updateData.name.trim() === '') {
+        throw new ValidationError('Badge name cannot be empty', 'name', updateData.name);
+      }
+      if (updateData.rarity !== undefined && !['common', 'rare', 'epic', 'legendary'].includes(updateData.rarity)) {
+        throw new ValidationError('Badge rarity must be one of: common, rare, epic, legendary', 'rarity', updateData.rarity);
+      }
+
       const updatedBadge = {
         ...existingBadge,
         ...updateData,
@@ -69,14 +109,13 @@ class Badge {
 
       const result = await couchdbService.createDocument(updatedBadge);
       return { ...updatedBadge, _rev: result.rev };
-    } catch (error) {
-      console.error('Error updating badge:', error);
-      throw error;
-    }
+    }, errorContext);
   }
 
   static async delete(id) {
-    try {
+    const errorContext = createErrorContext('Badge', 'delete', { badgeId: id });
+    
+    return await withErrorHandling(async () => {
       const badge = await couchdbService.get(id);
       if (badge.type !== 'badge') {
         throw new Error('Document is not a badge');
@@ -84,14 +123,16 @@ class Badge {
 
       await couchdbService.destroy(id, badge._rev);
       return true;
-    } catch (error) {
-      console.error('Error deleting badge:', error);
-      throw error;
-    }
+    }, errorContext);
   }
 
   static async findByCriteria(criteriaType, threshold) {
-    try {
+    const errorContext = createErrorContext('Badge', 'findByCriteria', { 
+      criteriaType, 
+      threshold 
+    });
+    
+    return await withErrorHandling(async () => {
       const result = await couchdbService.find({
         selector: {
           type: 'badge',
@@ -101,14 +142,17 @@ class Badge {
         sort: [{ 'criteria.threshold': 'desc' }]
       });
       return result.docs;
-    } catch (error) {
-      console.error('Error finding badges by criteria:', error);
-      throw error;
-    }
+    }, errorContext);
   }
 
   static async findByRarity(rarity) {
-    try {
+    const errorContext = createErrorContext('Badge', 'findByRarity', { rarity });
+    
+    return await withErrorHandling(async () => {
+      if (rarity && !['common', 'rare', 'epic', 'legendary'].includes(rarity)) {
+        throw new ValidationError('Badge rarity must be one of: common, rare, epic, legendary', 'rarity', rarity);
+      }
+
       const result = await couchdbService.find({
         selector: {
           type: 'badge',
@@ -117,10 +161,7 @@ class Badge {
         sort: [{ order: 'asc' }]
       });
       return result.docs;
-    } catch (error) {
-      console.error('Error finding badges by rarity:', error);
-      throw error;
-    }
+    }, errorContext);
   }
 }