Cách Mình Tích Hợp SEO Services

// lib/dataforseo.ts
const credentials = Buffer.from(
  `${process.env.DATAFORSEO_LOGIN}:${process.env.DATAFORSEO_PASSWORD}`
).toString('base64');

const headers = {
  'Authorization': `Basic ${credentials}`,
  'Content-Type': 'application/json',
};

interface SerpTask {
  keyword: string;
  location_code: number;
  language_code: string;
  device: 'desktop' | 'mobile';
}

interface SerpResult {
  keyword: string;
  items: Array<{
    type: string;
    rank_group: number;
    rank_absolute: number;
    title?: string;
    url?: string;
    description?: string;
  }>;
  ai_overview?: {
    text: string;
    sources: Array<{ url: string; title: string }>;
  };
}

async function fetchSerpResults(keywords: string[]): Promise<SerpResult[]> {
  const tasks: SerpTask[] = keywords.map(keyword => ({
    keyword,
    location_code: 2704,  // Việt Nam
    language_code: 'vi',
    device: 'desktop',
  }));

  const response = await fetch(
    'https://api.dataforseo.com/v3/serp/google/organic/live/advanced',
    {
      method: 'POST',
      headers,
      body: JSON.stringify(tasks),
    }
  );

  if (!response.ok) {
    throw new Error(`Lỗi DataForSEO: ${response.status}`);
  }

  const data = await response.json();
  return data.tasks.map(parseTaskResult);
}

async function checkAiOverviews(keywords: string[]): Promise<AiOverviewResult[]> {
  const tasks = keywords.map(keyword => ({
    keyword,
    location_code: 2840,  // USA (AI Overviews phổ biến hơn)
    language_code: 'en',
    device: 'desktop',
  }));

  const response = await fetch(
    'https://api.dataforseo.com/v3/serp/google/organic/live/advanced',
    {
      method: 'POST',
      headers,
      body: JSON.stringify(tasks),
    }
  );

  const data = await response.json();

  return data.tasks.map(task => {
    const aiOverview = task.result?.[0]?.items?.find(
      item => item.type === 'ai_overview'
    );

    return {
      keyword: task.data.keyword,
      hasAiOverview: !!aiOverview,
      content: aiOverview?.text || null,
      sources: aiOverview?.references || [],
    };
  });
}

// Xử lý theo batch 100 (kích thước batch khuyến nghị của họ)
async function batchProcess<T, R>(
  items: T[],
  processor: (batch: T[]) => Promise<R[]>,
  batchSize = 100
): Promise<R[]> {
  const results: R[] = [];

  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    const batchResults = await processor(batch);
    results.push(...batchResults);

    // Delay nhỏ giữa các batch
    if (i + batchSize < items.length) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }

  return results;
}

async function searchGoogle(query: string): Promise<SearchResult> {
  const params = new URLSearchParams({
    q: query,
    location: 'Vietnam',
    hl: 'vi',
    gl: 'vn',
    api_key: process.env.SERPAPI_KEY!,
  });

  const response = await fetch(
    `https://serpapi.com/search.json?${params}`
  );

  if (!response.ok) {
    throw new Error(`Lỗi SerpAPI: ${response.status}`);
  }

  return response.json();
}

import { Redis } from '@upstash/redis';

const redis = new Redis({
  url: process.env.UPSTASH_REDIS_URL!,
  token: process.env.UPSTASH_REDIS_TOKEN!,
});

async function getCachedOrFetch<T>(
  cacheKey: string,
  fetcher: () => Promise<T>,
  ttlSeconds = 3600  // Mặc định 1 giờ
): Promise<T> {
  // Thử cache trước
  const cached = await redis.get<T>(cacheKey);
  if (cached) {
    return cached;
  }

  // Lấy dữ liệu mới
  const data = await fetcher();

  // Cache cho lần sau
  await redis.setex(cacheKey, ttlSeconds, data);

  return data;
}

// Cách dùng
const results = await getCachedOrFetch(
  `serp:${keyword}:${location}`,
  () => fetchSerpResults([keyword]),
  86400  // Cache 24 giờ
);

async function fetchUniqueKeywords(keywords: string[]): Promise<SerpResult[]> {
  // Loại trùng và chuẩn hóa
  const uniqueKeywords = [...new Set(
    keywords.map(k => k.toLowerCase().trim())
  )];

  // Kiểm tra cache cho những gì đã fetch
  const cacheKeys = uniqueKeywords.map(k => `serp:${k}`);
  const cachedResults = await redis.mget<SerpResult[]>(...cacheKeys);

  const toFetch: string[] = [];
  const results: Map<string, SerpResult> = new Map();

  uniqueKeywords.forEach((keyword, i) => {
    if (cachedResults[i]) {
      results.set(keyword, cachedResults[i]);
    } else {
      toFetch.push(keyword);
    }
  });

  // Chỉ fetch những gì còn thiếu
  if (toFetch.length > 0) {
    const freshResults = await fetchSerpResults(toFetch);
    freshResults.forEach(result => {
      results.set(result.keyword.toLowerCase(), result);
    });
  }

  return uniqueKeywords.map(k => results.get(k)!);
}

async function fetchWithRetry<T>(
  fetcher: () => Promise<T>,
  maxRetries = 3
): Promise<T> {
  let lastError: Error | null = null;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fetcher();
    } catch (error) {
      lastError = error as Error;

      // Không retry lỗi client (4xx trừ 429)
      if (error instanceof Error && error.message.includes('4')) {
        if (!error.message.includes('429')) {
          throw error;
        }
      }

      // Exponential backoff: 1s, 2s, 4s
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }

  throw lastError;
}

// Domain type của mình
interface SerpEntry {
  position: number;
  url: string;
  title: string;
  description: string;
  type: 'organic' | 'featured' | 'ai_overview';
}

// Transformer cho DataForSEO
function transformDataForSeoResult(raw: any): SerpEntry[] {
  return raw.items
    .filter((item: any) => item.type === 'organic')
    .map((item: any) => ({
      position: item.rank_absolute,
      url: item.url,
      title: item.title,
      description: item.description,
      type: 'organic',
    }));
}

// Transformer cho SerpAPI
function transformSerpApiResult(raw: any): SerpEntry[] {
  return raw.organic_results.map((item: any) => ({
    position: item.position,
    url: item.link,
    title: item.title,
    description: item.snippet,
    type: 'organic',
  }));
}

// Log lời gọi API với ước tính chi phí
async function trackApiCall(
  provider: 'dataforseo' | 'serpapi',
  endpoint: string,
  itemCount: number
) {
  const costs = {
    dataforseo: {
      serp: 0.002,  // $0.002 mỗi từ khóa
      backlinks: 0.01,
    },
    serpapi: {
      search: 0.005,  // $0.005 mỗi tìm kiếm
    },
  };

  const cost = (costs[provider] as any)[endpoint] * itemCount;

  // Log vào database hoặc monitoring service
  await supabase.from('api_usage').insert({
    provider,
    endpoint,
    item_count: itemCount,
    estimated_cost: cost,
    timestamp: new Date().toISOString(),
  });

  console.log(`Lời gọi API: ${provider}/${endpoint} - ${itemCount} item - $${cost.toFixed(4)}`);
}