Add logging for submission data

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,