fix: Vibe coding on fixing the peroformance issues for gift suggestions (#697)

shashilo · alexappleget · web-flow · commit ce1ed54486d4 · 2025-11-21T08:28:17.000-06:00
* Vibe coding on fixing the peroformance issues for gift suggestions

* Clean: cleaned up the ai code some.

* Feature: updated AI model

* Fix: cleaned up more of the AI code

* Fix: deleted interface as not needed.

* Test: fixed failing tests

---------

Co-authored-by: Alex Appleget &lt;alexappleget2014@gmail.com&gt;
diff --git a/app/api/gift-exchanges/[id]/giftSuggestions/route.ts b/app/api/gift-exchanges/[id]/giftSuggestions/route.ts
@@ -27,11 +27,11 @@ export async function GET(
       throw new SupabaseError('User is not authenticated or exists', 500);
     }
 
-    // Get match with full profile info
-    const { data: match, error: matchError } = await supabase
-      .from('gift_exchange_members')
-      .select(
-        `
+    const [matchResult, suggestionsResult] = await Promise.all([
+      supabase
+        .from('gift_exchange_members')
+        .select(
+          `
         id,
         recipient_id,
         recipient:profiles!gift_exchange_members_recipient_id_profiles_fkey (
@@ -48,40 +48,39 @@ export async function GET(
           avatar
         )
       `,
-      )
-      .eq('gift_exchange_id', id)
-      .eq('user_id', user.id)
-      .single();
+        )
+        .eq('gift_exchange_id', id)
+        .eq('user_id', user.id)
+        .single(),
+      supabase
+        .from('gift_suggestions')
+        .select('*')
+        .eq('gift_exchange_id', id)
+        .eq('giver_id', user.id),
+    ]);
 
-    if (matchError) {
+    if (matchResult.error) {
       throw new SupabaseError(
         'Failed to fetch match',
-        matchError.code,
-        matchError,
+        matchResult.error.code,
+        matchResult.error,
       );
     }
 
-    // Get suggestions
-    const { data: suggestions, error: suggestionsError } = await supabase
-      .from('gift_suggestions')
-      .select('*')
-      .eq('gift_exchange_id', id)
-      .eq('giver_id', user.id);
-
-    if (suggestionsError) {
+    if (suggestionsResult.error) {
       throw new SupabaseError(
         'Failed to fetch suggestions',
-        suggestionsError.code,
-        suggestionsError,
+        suggestionsResult.error.code,
+        suggestionsResult.error,
       );
     }
 
     return NextResponse.json({
-      match: match.recipient,
-      suggestions: suggestions.map((s) => ({
-        ...s.suggestion,
-        id: s.id,
-        created_at: s.created_at,
+      match: matchResult.data?.recipient,
+      suggestions: (suggestionsResult.data || []).map((suggestion) => ({
+        ...suggestion.suggestion,
+        id: suggestion.id,
+        created_at: suggestion.created_at,
       })),
     });
   } catch (error) {
diff --git a/lib/drawGiftExchange.ts b/lib/drawGiftExchange.ts
@@ -69,40 +69,47 @@ export async function drawGiftExchange(
     // Shuffle members to assign
     const shuffledMembers = [...members].sort(() => Math.random() - 0.5);
 
-    // Update assignments
-    for (let i = 0; i < shuffledMembers.length; i++) {
-      const giver = shuffledMembers[i];
-      // Last person gives to first person, closing the circle
-      const recipient = shuffledMembers[(i + 1) % shuffledMembers.length];
-
-      const { error: updateError } = await supabase
-        .from('gift_exchange_members')
-        .update({
-          recipient_id: recipient.user_id,
-          has_drawn: true,
-        })
-        .eq('id', giver.id);
-
-      if (updateError) {
+    const assignments = shuffledMembers.map((member, index) => ({
+      giver: member,
+      recipient: shuffledMembers[(index + 1) % shuffledMembers.length],
+    }));
+
+    // Perform all member recipient assignments in parallel
+    const assignmentResults = await Promise.allSettled(
+      assignments.map((assignment) =>
+        supabase
+          .from('gift_exchange_members')
+          .update({ recipient_id: assignment.recipient.user_id, has_drawn: true })
+          .eq('id', assignment.giver.id),
+      ),
+    );
+
+    for (const result of assignmentResults) {
+      if (result.status === 'rejected') {
+        throw new SupabaseError('Failed to assign recipients', 500);
+      }
+      if ('value' in result && result.value.error) {
         throw new SupabaseError(
           'Failed to assign recipients',
-          updateError.code,
-          updateError,
+          result.value.error.code,
+          result.value.error,
         );
       }
-
-      // Fire and forget suggestions with error handling
-      // hacky way to avoid waiting for all suggestions to be generated
-      // avoids timeout issues
-      await generateAndStoreSuggestions(
-        supabase,
-        exchangeId,
-        giver.user_id,
-        recipient.user_id,
-        exchange.budget,
-      );
     }
 
+    // Generate suggestions for all members concurrently (do not block one another)
+    await Promise.allSettled(
+      assignments.map((assignment) =>
+        generateAndStoreSuggestions(
+          supabase,
+          exchangeId,
+          assignment.giver.user_id,
+          assignment.recipient.user_id,
+          exchange.budget,
+        ),
+      ),
+    );
+
     // Update exchange status to active
     const { error: statusError } = await supabase
       .from('gift_exchanges')
diff --git a/lib/generateAndStoreSuggestions.test.ts b/lib/generateAndStoreSuggestions.test.ts
@@ -96,7 +96,8 @@ describe('generateAndStoreSuggestions', () => {
     expect(getAmazonImage).toHaveBeenCalledWith('Kindle Paperwhite');
     expect(mockFrom).toHaveBeenCalledWith('gift_suggestions');
     expect(mockInsert).toHaveBeenCalledWith(
-      expect.objectContaining({
+      expect.arrayContaining([
+        expect.objectContaining({
         gift_exchange_id: 'Exchange1',
         giver_id: 'Giver1',
         recipient_id: 'Recipient1',
@@ -105,6 +106,7 @@ describe('generateAndStoreSuggestions', () => {
           imageUrl: 'https://amazon.com/kindle.jpg',
         }),
       }),
+      ])
     );
   });
 
diff --git a/lib/generateAndStoreSuggestions.ts b/lib/generateAndStoreSuggestions.ts
@@ -5,6 +5,9 @@ import { SupabaseClient } from '@supabase/supabase-js';
 import { openai } from '../app/api/openaiConfig/config';
 import { getAmazonImage } from './getAmazonImage';
 import { SupabaseError, OpenAiError } from './errors/CustomErrors';
+import {
+  IGeneratedSuggestionNormalized,
+} from './interfaces/IGeneratedSuggestionRaw';
 
 /**
  * Generates and store gift suggestions
@@ -69,7 +72,7 @@ export async function generateAndStoreSuggestions(
 
     const completion = await openai.chat.completions.create({
       messages: [{ role: 'user', content: prompt }],
-      model: 'gpt-3.5-turbo',
+      model: 'gpt-4o-mini',
       temperature: 0.7,
     });
 
@@ -99,39 +102,62 @@ export async function generateAndStoreSuggestions(
       }
     }
 
-    const parsedResponse = JSON.parse(jsonContent);
+    const rawItems = JSON.parse(jsonContent) as Array<Record<string, unknown>>;
 
-    // Process each suggestion with Amazon data
-    for (const suggestion of parsedResponse) {
-      const amazonData = await getAmazonImage(suggestion.title);
+    const parsedResponse = rawItems.map((item) => {
 
-      const cleanSuggestion = {
-        title: String(suggestion.title),
-        price: String(suggestion.price),
-        description: String(suggestion.description),
-        matchReasons: Array.isArray(suggestion.matchReasons)
-          ? suggestion.matchReasons.map(String)
+      return {
+        title: String(item.title),
+        price: String(item.price),
+        description: String(item.description),
+        matchReasons: Array.isArray(item.matchReasons)
+          ? item.matchReasons.map(String)
           : [],
-        matchScore: Number(suggestion.matchScore),
-        imageUrl: amazonData.imageUrl || null,
+        matchScore: Number(item.matchScore),
       };
+    });
 
-      const { error: suggestionError } = await supabase
-        .from('gift_suggestions')
-        .insert({
-          gift_exchange_id: exchangeId,
-          giver_id: giverId,
-          recipient_id: recipientId,
-          suggestion: cleanSuggestion,
-        });
-
-      if (suggestionError) {
-        throw new SupabaseError(
-          'Failed to store suggestion',
-          suggestionError.code,
-          suggestionError,
-        );
-      }
+    const imageResults = await Promise.allSettled(
+      parsedResponse.map((response) => getAmazonImage(String(response.title))),
+    );
+
+    const rows = parsedResponse.map((suggestion, idx): {
+      gift_exchange_id: string;
+      giver_id: string;
+      recipient_id: string;
+      suggestion: IGeneratedSuggestionNormalized;
+    } => {
+      const imageResult = imageResults[idx];
+      const imageUrl =
+        imageResult.status === 'fulfilled' && imageResult.value.imageUrl
+          ? imageResult.value.imageUrl
+          : null;
+
+      return {
+        gift_exchange_id: exchangeId,
+        giver_id: giverId,
+        recipient_id: recipientId,
+        suggestion: {
+          title: suggestion.title,
+          price: suggestion.price,
+          description: suggestion.description,
+          matchReasons: suggestion.matchReasons,
+          matchScore: suggestion.matchScore,
+          imageUrl,
+        },
+      };
+    });
+
+    const { error: insertError } = await supabase
+      .from('gift_suggestions')
+      .insert(rows);
+
+    if (insertError) {
+      throw new SupabaseError(
+        'Failed to store suggestions',
+        insertError.code,
+        insertError,
+      );
     }
   } catch (error) {
     throw error;
diff --git a/lib/interfaces/IGeneratedSuggestionRaw.ts b/lib/interfaces/IGeneratedSuggestionRaw.ts
@@ -0,0 +1,11 @@
+// Copyright (c) Gridiron Survivor.
+// Licensed under the MIT License.
+
+export interface IGeneratedSuggestionNormalized {
+  title: string;
+  price: string;
+  description: string;
+  matchReasons: string[];
+  matchScore: number;
+  imageUrl: string | null;
+}
