Add logging for submission data

src/hooks/moderation/useModerationActions.ts

@@ -154,6 +154,13 @@ export function useModerationActions(config: ModerationActionsConfig): Moderatio
             }
             
             if (fullItems && fullItems.length > 0) {
+              console.info('[Submission Flow] Preparing items for validation', {
+                submissionId: item.id,
+                itemCount: fullItems.length,
+                itemTypes: fullItems.map(i => i.item_type),
+                timestamp: new Date().toISOString()
+              });
+
               // Transform to include item_data
               const itemsWithData = fullItems.map(item => {
                 let itemData = {};
@@ -166,6 +173,14 @@ export function useModerationActions(config: ModerationActionsConfig): Moderatio
                       location: parkSub.temp_location_data || undefined,
                       temp_location_data: undefined
                     };
+                    
+                    console.info('[Submission Flow] Transformed park data for validation', {
+                      itemId: item.id,
+                      hasLocation: !!parkSub.temp_location_data,
+                      locationData: parkSub.temp_location_data,
+                      transformedHasLocation: !!(itemData as any).location,
+                      timestamp: new Date().toISOString()
+                    });
                     break;
                   }
                   case 'ride':
@@ -202,8 +217,21 @@ export function useModerationActions(config: ModerationActionsConfig): Moderatio
               
               // Run validation on all items
               try {
+                console.info('[Submission Flow] Starting validation', {
+                  submissionId: item.id,
+                  itemCount: itemsWithData.length,
+                  itemTypes: itemsWithData.map(i => i.item_type),
+                  timestamp: new Date().toISOString()
+                });
+
                 const validationResults = await validateMultipleItems(itemsWithData);
                 
+                console.info('[Submission Flow] Validation completed', {
+                  submissionId: item.id,
+                  resultsCount: validationResults.size,
+                  timestamp: new Date().toISOString()
+                });
+
                 // Check for blocking errors
                 const itemsWithBlockingErrors = itemsWithData.filter(item => {
                   const result = validationResults.get(item.id);
@@ -212,6 +240,16 @@ export function useModerationActions(config: ModerationActionsConfig): Moderatio
                 
                 // CRITICAL: Block approval if any item has blocking errors
                 if (itemsWithBlockingErrors.length > 0) {
+                  console.warn('[Submission Flow] Validation found blocking errors', {
+                    submissionId: item.id,
+                    itemsWithErrors: itemsWithBlockingErrors.map(i => ({
+                      itemId: i.id,
+                      itemType: i.item_type,
+                      errors: validationResults.get(i.id)?.blockingErrors
+                    })),
+                    timestamp: new Date().toISOString()
+                  });
+
                   // Log detailed blocking errors
                   itemsWithBlockingErrors.forEach(item => {
                     const result = validationResults.get(item.id);

src/lib/submissionItemsService.ts

@@ -232,13 +232,27 @@ export async function updateSubmissionItem(
 ): Promise<void> {
   const { item_data, original_data, ...cleanUpdates } = updates;
   
+  // Log submission item update start
+  console.info('[Submission Flow] Update item start', {
+    itemId,
+    hasItemData: !!item_data,
+    statusUpdate: cleanUpdates.status,
+    timestamp: new Date().toISOString()
+  });
+  
   // Update submission_items table
   const { error } = await supabase
     .from('submission_items')
     .update(cleanUpdates)
     .eq('id', itemId);
 
-  if (error) throw error;
+  if (error) {
+    handleError(error, {
+      action: 'Update Submission Item',
+      metadata: { itemId, updates: cleanUpdates }
+    });
+    throw error;
+  }
 
   // If item_data is provided, update the relational table
   if (item_data !== undefined) {
@@ -272,12 +286,37 @@ export async function updateSubmissionItem(
           if (updateData[key] === undefined) delete updateData[key];
         });
 
+        console.info('[Submission Flow] Saving park data', {
+          itemId,
+          parkSubmissionId: item.park_submission_id,
+          hasLocation: !!updateData.temp_location_data,
+          locationData: updateData.temp_location_data,
+          fields: Object.keys(updateData),
+          timestamp: new Date().toISOString()
+        });
+
         const { error: updateError } = await supabase
           .from('park_submissions')
           .update(updateData)
           .eq('id', item.park_submission_id);
 
-        if (updateError) throw updateError;
+        if (updateError) {
+          handleError(updateError, {
+            action: 'Update Park Submission Data',
+            metadata: { 
+              itemId, 
+              parkSubmissionId: item.park_submission_id,
+              updateFields: Object.keys(updateData)
+            }
+          });
+          throw updateError;
+        }
+        
+        console.info('[Submission Flow] Park data saved successfully', {
+          itemId,
+          parkSubmissionId: item.park_submission_id,
+          timestamp: new Date().toISOString()
+        });
         break;
       }
       case 'ride': {
@@ -340,6 +379,14 @@ export async function approveSubmissionItems(
     throw new Error('User authentication required to approve items');
   }
 
+  console.info('[Submission Flow] Approval process started', {
+    itemCount: items.length,
+    itemIds: items.map(i => i.id),
+    itemTypes: items.map(i => i.item_type),
+    userId,
+    timestamp: new Date().toISOString()
+  });
+
   // Sort by dependency order (parents first)
   const sortedItems = topologicalSort(items);
   
@@ -363,6 +410,15 @@ export async function approveSubmissionItems(
         ('ride_model_id' in itemData && itemData.ride_model_id)
       );
 
+      console.info('[Submission Flow] Processing item for approval', {
+        itemId: item.id,
+        itemType: item.item_type,
+        isEdit,
+        hasLocation: !!(itemData as any).location,
+        locationData: (itemData as any).location,
+        timestamp: new Date().toISOString()
+      });
+
       // Create the entity based on type with dependency resolution
       // PASS sortedItems to enable correct index-based resolution
       switch (item.item_type) {
@@ -390,6 +446,14 @@ export async function approveSubmissionItems(
         throw new Error(`Failed to create ${item.item_type}: no entity ID returned`);
       }
 
+      console.info('[Submission Flow] Entity created successfully', {
+        itemId: item.id,
+        itemType: item.item_type,
+        entityId,
+        isEdit,
+        timestamp: new Date().toISOString()
+      });
+
       // Update item status
       await updateSubmissionItem(item.id, {
         status: 'approved' as const,