update: resolved (https://www.notion.so/19-ago-25065f54faae8011b886e2cba859a457)

Author: Johnmiicheal

src/app/api/keywords-analysis/route.ts

@@ -101,8 +101,8 @@ export async function POST(req: NextRequest) {
 
     console.log('Sending webhook request with query params:', chatInputData);
 
-    // Make request to Railway webhook using GET with query parameters
-    const webhookUrl = `https://primary-production-20a3.up.railway.app/webhook/dc520c2d-e515-4e54-b838-fc728c2a24ea?chatInput=${chatInputParam}`;
+    // Make request to new webhook endpoint using GET with query parameters
+    const webhookUrl = `https://automations.ideacharge.com/webhook/keywordresearchair?chatInput=${chatInputParam}`;
 
     const webhookResponse = await fetch(webhookUrl, {
       method: 'GET',
@@ -121,9 +121,9 @@ export async function POST(req: NextRequest) {
     }
 
     const keywordResults = await webhookResponse.json();
-    console.log('Keyword Results:', webhookResponse);
+    console.log('Keyword Results:', JSON.stringify(keywordResults, null, 2));
 
-    // Validate response structure - webhook returns array with output object
+    // Validate response structure - webhook returns array of keyword objects with results/keywords properties
     if (!keywordResults || !Array.isArray(keywordResults) || keywordResults.length === 0) {
       console.error('Invalid webhook response structure:', keywordResults);
       return NextResponse.json(
@@ -132,11 +132,14 @@ export async function POST(req: NextRequest) {
       );
     }
 
-    const outputData = keywordResults[0]?.output;
-    if (!outputData || !outputData.keywords) {
-      console.error('Invalid webhook response - missing output.keywords:', keywordResults);
+    // Filter out metadata objects and get actual keyword data
+    const keywordData = keywordResults.filter(item => item.keywords && item.results);
+    const metadata = keywordResults.find(item => item.metadata);
+
+    if (keywordData.length === 0) {
+      console.error('Invalid webhook response - no keyword data found:', keywordResults);
       return NextResponse.json(
-        { error: 'Invalid response from keyword analysis service - missing keywords data' },
+        { error: 'Invalid response from keyword analysis service - no keywords data found' },
         { status: 500, headers: corsHeaders }
       );
     }
@@ -145,16 +148,31 @@ export async function POST(req: NextRequest) {
     const analysisId = crypto.randomUUID();
 
     // Define types for keyword processing
+    interface MonthlySearchVolume {
+      month: string;
+      year: string;
+      monthlySearches: string;
+    }
+
+
+
     interface ProcessedKeyword {
       conversational_keyword: string;
       intent: string | null;
       google_seed_keyword: string | null;
       category: string | null;
       search_volume: number;
       competition_index: number;
-      low_cpc: string;
+      competition: string | null;
+      low_cpc: string | null;
+      high_cpc: string | null;
+      low_cpc_usd: string | null;
+      high_cpc_usd: string | null;
+      trend_3m: string;
       trend_6m: string;
+      trend_11m: string;
       relevance_score: number;
+      monthly_search_volumes: MonthlySearchVolume[];
     }
 
     interface KeywordStats {
@@ -176,55 +194,123 @@ export async function POST(req: NextRequest) {
       category_distribution: {}
     };
 
-    if (outputData.keywords && typeof outputData.keywords === 'object') {
-      // Convert object with numbered keys to array
-      keywordsArray = Object.values(outputData.keywords).map((keywordData) => {
-        const data = keywordData as Record<string, unknown>;
-        return {
-          conversational_keyword: String(data.conversational_keyword || ''),
-          intent: data.intent ? String(data.intent) : null,
-          google_seed_keyword: data.google_seed_keyword ? String(data.google_seed_keyword) : null,
-          category: data.category ? String(data.category) : null,
-          search_volume: parseInt(String(data.search_volume || 0)) || 0,
-          competition_index: parseFloat(String(data.competition_index || 0)) || 0,
-          low_cpc: String(data.low_cpc || '$0.00'),
-          trend_6m: String(data.trend_6m || '0%'),
-          relevance_score: parseFloat(String(data.relevance_score || 0)) || 0,
-        };
-      });
-
-      // Get top 10 keywords by relevance score for quick dashboard access
-      topKeywords = keywordsArray
-        .sort((a, b) => b.relevance_score - a.relevance_score)
-        .slice(0, 10);
-
-      // Calculate quick stats
-      const totalKeywords = keywordsArray.length;
-      const avgRelevance = keywordsArray.reduce((sum, kw) => sum + kw.relevance_score, 0) / totalKeywords;
-      const highVolumeCount = keywordsArray.filter(kw => kw.search_volume > 1000).length;
-      const intentCounts = keywordsArray.reduce((acc: Record<string, number>, kw) => {
-        const intent = kw.intent || 'unknown';
-        acc[intent] = (acc[intent] || 0) + 1;
-        return acc;
-      }, {});
-      const categoryCounts = keywordsArray.reduce((acc: Record<string, number>, kw) => {
-        const category = kw.category || 'unknown';
-        acc[category] = (acc[category] || 0) + 1;
-        return acc;
-      }, {});
-
-      stats = {
-        total_keywords: totalKeywords,
-        avg_relevance_score: Math.round(avgRelevance * 10) / 10,
-        high_volume_count: highVolumeCount,
-        intent_distribution: intentCounts,
-        category_distribution: categoryCounts
+    // Process each keyword from the new structure
+    keywordsArray = keywordData.map((item: Record<string, unknown>) => {
+      const results = (item.results || {}) as Record<string, unknown>;
+      const keywords = (item.keywords || {}) as Record<string, unknown>;
+      const keywordMetrics = (results.keywordMetrics || {}) as Record<string, unknown>;
+      
+      // Extract search volume from avgMonthlySearches
+      const avgMonthlySearches = parseInt(String(keywordMetrics.avgMonthlySearches || '0')) || 0;
+      
+      // Extract competition index
+      const competitionIndex = parseFloat(String(keywordMetrics.competitionIndex || '0')) || 0;
+      
+      // Extract trends
+      const trends = (keywordMetrics.trends || {}) as Record<string, unknown>;
+      
+      return {
+        conversational_keyword: String(keywords.conversational_keyword || ''),
+        intent: keywords.intent ? String(keywords.intent) : null,
+        google_seed_keyword: String(keywords.google_seed_keyword || results.text || ''),
+        category: keywords.category ? String(keywords.category) : null,
+        search_volume: avgMonthlySearches,
+        competition_index: competitionIndex,
+        competition: keywordMetrics.competition ? String(keywordMetrics.competition) : null,
+        low_cpc: keywordMetrics.lowTopOfPageBid ? String(keywordMetrics.lowTopOfPageBid) : null,
+        high_cpc: keywordMetrics.highTopOfPageBid ? String(keywordMetrics.highTopOfPageBid) : null,
+        low_cpc_usd: keywordMetrics.lowTopOfPageBidUSD ? String(keywordMetrics.lowTopOfPageBidUSD) : null,
+        high_cpc_usd: keywordMetrics.highTopOfPageBidUSD ? String(keywordMetrics.highTopOfPageBidUSD) : null,
+        trend_3m: String(trends['3m_trend'] || '0%'),
+        trend_6m: String(trends['6m_trend'] || '0%'),
+        trend_11m: String(trends['11m_trend'] || '0%'),
+        relevance_score: parseFloat(String(keywords.relevance_score || 0)) || 0,
+        monthly_search_volumes: (keywordMetrics.monthlySearchVolumes || []) as MonthlySearchVolume[],
       };
-    }
+    });
+
+    // Get top 10 keywords by relevance score for quick dashboard access
+    topKeywords = keywordsArray
+      .sort((a, b) => b.relevance_score - a.relevance_score)
+      .slice(0, 10);
 
+    // Calculate quick stats
     const totalKeywords = keywordsArray.length;
+    const avgRelevance = keywordsArray.reduce((sum, kw) => sum + kw.relevance_score, 0) / totalKeywords;
+    const highVolumeCount = keywordsArray.filter(kw => kw.search_volume > 1000).length;
+    const intentCounts = keywordsArray.reduce((acc: Record<string, number>, kw) => {
+      const intent = kw.intent || 'unknown';
+      acc[intent] = (acc[intent] || 0) + 1;
+      return acc;
+    }, {});
+    const categoryCounts = keywordsArray.reduce((acc: Record<string, number>, kw) => {
+      const category = kw.category || 'unknown';
+      acc[category] = (acc[category] || 0) + 1;
+      return acc;
+    }, {});
+
+    stats = {
+      total_keywords: totalKeywords,
+      avg_relevance_score: Math.round(avgRelevance * 10) / 10,
+      high_volume_count: highVolumeCount,
+      intent_distribution: intentCounts,
+      category_distribution: categoryCounts
+    };
+
+    // Calculate additional metrics for new database columns
+    const totalMonthlySearches = keywordsArray.reduce((sum, kw) => sum + kw.search_volume, 0);
+    const avgSearchVolume = Math.round(totalMonthlySearches / totalKeywords) || 0;
+    const highCompetitionCount = keywordsArray.filter(kw => kw.competition_index > 50).length;
+    const avgCompetitionIndex = keywordsArray.reduce((sum, kw) => sum + kw.competition_index, 0) / totalKeywords;
+
+    // Analyze competition distribution
+    const competitionDistribution = keywordsArray.reduce((acc: Record<string, number>, kw) => {
+      const competition = kw.competition || 'UNKNOWN';
+      acc[competition] = (acc[competition] || 0) + 1;
+      return acc;
+    }, {});
+
+    // Analyze CPC data
+    const validCpcs = keywordsArray.filter(kw => kw.low_cpc && kw.low_cpc !== '$0.00');
+    const validCpcsUsd = keywordsArray.filter(kw => kw.low_cpc_usd && kw.low_cpc_usd !== '$0.00');
+    const cpcAnalysis = {
+      has_cpc_data: validCpcs.length > 0 || validCpcsUsd.length > 0,
+      keywords_with_cpc: validCpcs.length,
+      keywords_with_cpc_usd: validCpcsUsd.length,
+      avg_low_cpc: validCpcs.length > 0 ? 
+        validCpcs.reduce((sum, kw) => sum + parseFloat(kw.low_cpc?.replace('$', '') || '0'), 0) / validCpcs.length : 0,
+      avg_high_cpc: validCpcs.length > 0 ? 
+        validCpcs.reduce((sum, kw) => sum + parseFloat(kw.high_cpc?.replace('$', '') || '0'), 0) / validCpcs.length : 0,
+      avg_low_cpc_usd: validCpcsUsd.length > 0 ? 
+        validCpcsUsd.reduce((sum, kw) => sum + parseFloat(kw.low_cpc_usd?.replace('$', '') || '0'), 0) / validCpcsUsd.length : 0,
+      avg_high_cpc_usd: validCpcsUsd.length > 0 ? 
+        validCpcsUsd.reduce((sum, kw) => sum + parseFloat(kw.high_cpc_usd?.replace('$', '') || '0'), 0) / validCpcsUsd.length : 0,
+      max_cpc_usd: validCpcsUsd.length > 0 ? 
+        Math.max(...validCpcsUsd.map(kw => parseFloat(kw.high_cpc_usd?.replace('$', '') || '0'))) : 0,
+      min_cpc_usd: validCpcsUsd.length > 0 ? 
+        Math.min(...validCpcsUsd.map(kw => parseFloat(kw.low_cpc_usd?.replace('$', '') || '0'))) : 0
+    };
 
-    // Save the analysis session with embedded keywords data
+    // Analyze trends
+    const trendAnalysis = {
+      positive_3m_trends: keywordsArray.filter(kw => kw.trend_3m.includes('+')).length,
+      negative_3m_trends: keywordsArray.filter(kw => kw.trend_3m.includes('-')).length,
+      positive_6m_trends: keywordsArray.filter(kw => kw.trend_6m.includes('+')).length,
+      negative_6m_trends: keywordsArray.filter(kw => kw.trend_6m.includes('-')).length,
+      positive_11m_trends: keywordsArray.filter(kw => kw.trend_11m.includes('+')).length,
+      negative_11m_trends: keywordsArray.filter(kw => kw.trend_11m.includes('-')).length,
+    };
+
+    // Calculate high-value keywords (>$5 USD CPC)
+    const highValueKeywordsCount = keywordsArray.filter(kw => {
+      const highCpcUsd = parseFloat(kw.high_cpc_usd?.replace('$', '') || '0');
+      return highCpcUsd > 5;
+    }).length;
+
+    // Generate analysis summary based on the results
+    const analysisSummary = `Analyzed ${totalKeywords} keywords with an average relevance score of ${stats.avg_relevance_score}. Found ${stats.high_volume_count} high-volume keywords (>1000 monthly searches). Average search volume: ${avgSearchVolume}/month. ${validCpcsUsd.length > 0 ? `Average CPC: $${cpcAnalysis.avg_low_cpc_usd.toFixed(2)}-$${cpcAnalysis.avg_high_cpc_usd.toFixed(2)} USD. ` : ''}Top intents: ${Object.keys(stats.intent_distribution).slice(0, 3).join(', ')}.`;
+
+    // Save the analysis session with embedded keywords data and new metrics
     const { error: sessionError } = await supabase
       .from('keyword_analysis_sessions')
       .insert({
@@ -234,12 +320,28 @@ export async function POST(req: NextRequest) {
         website: website,
         keyword_input: keyword,
         total_keywords: totalKeywords,
-        analysis_summary: outputData.summary || '',
+        analysis_summary: analysisSummary,
         keywords_data: keywordsArray,
         top_keywords: topKeywords,
         stats: stats,
-        language: language,
-        location: location,
+        language: metadata?.language || language || 'en',
+        location: metadata?.country || location || 'Global',
+        // New calculated metrics
+        avg_search_volume: avgSearchVolume,
+        total_monthly_searches: totalMonthlySearches,
+        high_competition_count: highCompetitionCount,
+        avg_competition_index: Math.round(avgCompetitionIndex * 100) / 100,
+        trend_analysis: trendAnalysis,
+        response_metadata: metadata || { language: language || 'en', country: location || 'Global' },
+        competition_distribution: competitionDistribution,
+        cpc_analysis: cpcAnalysis,
+        // Enhanced CPC metrics
+        avg_low_cpc_usd: Math.round(cpcAnalysis.avg_low_cpc_usd * 100) / 100,
+        avg_high_cpc_usd: Math.round(cpcAnalysis.avg_high_cpc_usd * 100) / 100,
+        max_cpc_usd: Math.round(cpcAnalysis.max_cpc_usd * 100) / 100,
+        min_cpc_usd: Math.round(cpcAnalysis.min_cpc_usd * 100) / 100,
+        keywords_with_cpc_data: validCpcsUsd.length,
+        high_value_keywords_count: highValueKeywordsCount,
       });
 
     if (sessionError) {
@@ -276,7 +378,12 @@ export async function POST(req: NextRequest) {
 
     return NextResponse.json({
       success: true,
-      data: outputData,
+      data: {
+        keywords: keywordsArray,
+        summary: analysisSummary,
+        stats: stats,
+        metadata: metadata || { language: language || 'en', country: location || 'Global' }
+      },
       keyword_id: analysisId // Include the analysis ID for redirect
     }, { headers: corsHeaders });
 

src/app/api/onboarding-autofill/route.ts

@@ -34,11 +34,21 @@ export async function POST(request: NextRequest) {
     }
 
     const data = await response.json();
+    
+    // The external API returns an array with an object containing output
+    // Format: [{"output": {...}}]
+    if (!Array.isArray(data) || data.length === 0 || !data[0].output) {
+      console.error("Unexpected response format:", data);
+      return NextResponse.json(
+        { error: "Invalid response format from external API" },
+        { status: 500 }
+      );
+    }
 
     // Return the autofill data
     return NextResponse.json({
       success: true,
-      data: data.output,
+      data: data[0].output,
     });
   } catch (error) {
     console.error("Onboarding autofill error:", error);