Programmatic SEO z Next.js i AI — jak generować tysiące zoptymalizowanych stron

// app/[miasto]/[usluga]/page.tsx
import { notFound } from 'next/navigation';
import cities from '@/data/cities.json';
import services from '@/data/services.json';
 
// W Next.js 15+ kombinacje, które nie istnieją w danych, mają zwracać 404
export const dynamicParams = false;
 
// Generuje ścieżki dla wszystkich kombinacji miasto × usługa
export async function generateStaticParams() {
  const params = [];
 
  for (const city of cities) {
    for (const service of services) {
      // Pomijaj kombinacje, które nie mają sensu (usługa niedostępna w mieście)
      if (service.unavailableIn?.includes(city.slug)) continue;
 
      params.push({
        miasto: city.slug,
        usluga: service.slug,
      });
    }
  }
 
  return params; // np. 50 miast × 10 usług ≈ 500 stron
}
 
// W Next.js 15+ `params` to Promise — trzeba je rozpakować przez await
export async function generateMetadata({
  params,
}: {
  params: Promise<{ miasto: string; usluga: string }>;
}) {
  const { miasto, usluga } = await params;
  const city = cities.find((c) => c.slug === miasto);
  const service = services.find((s) => s.slug === usluga);
 
  return {
    title: `${service.name} ${city.name} - cena, termin, zakres`,
    description: `${service.name} w ${city.nameDeclension}. Sprawdź zakres, koszt i wymagania. Aktualne informacje na ${new Date().getFullYear()} rok.`,
    alternates: {
      canonical: `https://twojadomena.pl/${miasto}/${usluga}`,
    },
  };
}
 
export default async function ServiceCityPage({
  params,
}: {
  params: Promise<{ miasto: string; usluga: string }>;
}) {
  const { miasto, usluga } = await params;
  const city = cities.find((c) => c.slug === miasto);
  const service = services.find((s) => s.slug === usluga);
 
  // Kombinacja spoza generateStaticParams (lub usunięta z danych) → 404
  if (!city || !service) notFound();
 
  const content = await getGeneratedContent(miasto, usluga);
 
  return (
    <main>
      <h1>
        {service.name} {city.name}
      </h1>
 
      {/* TLDR-first — natychmiast odpowiedź na pytanie */}
      <p className="lead">{content.tldr}</p>
 
      {/* Sekcje treści z danych strukturalnych + AI */}
      <section>
        <h2>Zakres {service.nameGenitive} w {city.nameDeclension}</h2>
        <p>{content.scope}</p>
      </section>
 
      <section>
        <h2>Ile kosztuje {service.name.toLowerCase()} w {city.nameDeclension}?</h2>
        <p>{content.pricing}</p>
      </section>
 
      <section>
        <h2>Jak często wykonywać {service.name.toLowerCase()}?</h2>
        <p>{content.frequency}</p>
      </section>
 
      <section>
        <h2>Podstawa prawna</h2>
        <p>{content.legalBasis}</p>
      </section>
 
      {/* FAQ z FAQPage schema */}
      <FaqSection items={content.faq} />
 
      {/* Linkowanie wewnętrzne */}
      <RelatedServices city={city} currentService={service} />
      <NearbyCities service={service} currentCity={city} />
 
      {/* Structured data */}
      <ServiceJsonLd city={city} service={service} content={content} />
    </main>
  );
}

// Na poziomie segmentu (layout lub page)
export const revalidate = 86400 // Regeneracja co 24h
 
// Lub on-demand revalidation z API route
// app/api/revalidate/route.ts
import { revalidatePath } from 'next/cache'
 
export async function POST(request: Request) {
  const { secret, path } = await request.json()
 
  if (secret !== process.env.REVALIDATION_SECRET) {
    return Response.json({ error: 'Unauthorized' }, { status: 401 })
  }
 
  revalidatePath(path)
  return Response.json({ revalidated: true })
}

// scripts/generate-content.ts
import Anthropic from '@anthropic-ai/sdk'
import cities from '../data/cities.json'
import services from '../data/services.json'
import { writeFile, mkdir } from 'fs/promises'
 
const anthropic = new Anthropic()
 
interface GeneratedContent {
  tldr: string
  scope: string
  pricing: string
  frequency: string
  legalBasis: string
  faq: Array<{ question: string; answer: string }>
}
 
async function generateContent(
  city: (typeof cities)[0],
  service: (typeof services)[0],
): Promise<GeneratedContent> {
  const systemPrompt = `Jesteś ekspertem ds. inspekcji budowlanych w Polsce. 
Piszesz profesjonalne, merytoryczne treści po polsku. 
Używaj konkretnych danych: cen, terminów, numerów ustaw i rozporządzeń.
NIE generuj ogólników — każda informacja musi być specyficzna 
dla danego miasta i typu usługi.
Format odpowiedzi: JSON zgodny z podanym schematem.`
 
  const userPrompt = `Wygeneruj treść strony o usłudze "${service.name}" 
w mieście ${city.name} (województwo ${city.voivodeship}).
 
Kontekst:
- Populacja miasta: ${city.population}
- Liczba budynków mieszkalnych: ${city.residentialBuildings}
- Specyfika regionalna: ${city.regionalContext}
- Przepisy dotyczące usługi: ${service.regulations}
- Typowy zakres cenowy w Polsce: ${service.priceRange}
 
Wygeneruj JSON z polami:
- tldr: 2-3 zdania podsumowujące najważniejsze informacje (co, kiedy, ile)
- scope: szczegółowy opis zakresu usługi (3-4 akapity)
- pricing: informacja o kosztach z kontekstem lokalnym (2-3 akapity)
- frequency: jak często wymagana, podstawa prawna (2 akapity)
- legalBasis: konkretne przepisy (ustawa, rozporządzenie, artykuł)
- faq: 5 pytań i odpowiedzi specyficznych dla tej usługi w tym mieście
 
Odpowiedz WYŁĄCZNIE JSON-em, bez markdown, bez backtickow.`
 
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 4000,
    system: systemPrompt,
    messages: [{ role: 'user', content: userPrompt }],
  })
 
  const text = response.content
    .filter((block) => block.type === 'text')
    .map((block) => block.text)
    .join('')
 
  return JSON.parse(text) as GeneratedContent
}
 
// Generowanie treści dla wszystkich kombinacji.
// W produkcji opakuj pętlę w obsługę błędów per strona i rate limiting
// (np. pauza ~1s między requestami albo kolejka z limitem współbieżności),
// żeby nie wpaść w limity API przy setkach kombinacji.
async function generateAll() {
  await mkdir('data/generated', { recursive: true })
 
  for (const city of cities) {
    for (const service of services) {
      const content = await generateContent(city, service)
      const filepath = `data/generated/${city.slug}-${service.slug}.json`
      await writeFile(filepath, JSON.stringify(content, null, 2))
    }
  }
}
 
generateAll()

function validateContent(content: GeneratedContent): string[] {
  const errors: string[] = []
 
  if (content.tldr.length < 100) errors.push('TLDR za krótkie')
  if (content.scope.length < 500) errors.push('Zakres za krótki')
  if (content.faq.length < 3) errors.push('Za mało pytań FAQ')
 
  // Sprawdź duplikaty FAQ
  const questions = content.faq.map((f) => f.question.toLowerCase())
  const uniqueQuestions = new Set(questions)
  if (uniqueQuestions.size !== questions.length)
    errors.push('Zduplikowane pytania FAQ')
 
  return errors
}

// Szablon z dynamiczną personalizacją
export async function generateMetadata({ params }) {
  const { miasto, usluga } = await params
  const city = getCityData(miasto)
  const service = getServiceData(usluga)
 
  // Warianty tytułów — unikaj identycznych meta tagów
  const titleVariants = [
    `${service.name} ${city.name} — cena, zakres, termin ${currentYear}`,
    `${service.name} w ${city.nameDeclension} — ile kosztuje i jak przebiega`,
    `${service.name} ${city.name} — kompletny przewodnik ${currentYear}`,
  ]
 
  // Wybierz wariant na podstawie hasha slug
  const titleIndex = hashString(miasto + usluga) % titleVariants.length
 
  return {
    title: titleVariants[titleIndex],
    description: `Wszystko o ${service.nameLocative} w ${city.nameDeclension}. Aktualny cennik, wymagane dokumenty, częstotliwość i podstawa prawna. Informacje zaktualizowane na ${currentYear} rok.`,
  }
}

function ServiceJsonLd({ city, service, content }) {
  const jsonLd = {
    '@context': 'https://schema.org',
    '@type': 'Service',
    name: `${service.name} ${city.name}`,
    description: content.tldr,
    areaServed: {
      '@type': 'City',
      name: city.name,
      containedInPlace: {
        '@type': 'AdministrativeArea',
        name: city.voivodeship,
      },
    },
    provider: {
      '@type': 'Organization',
      name: 'Twoja Firma',
      url: 'https://twojadomena.pl',
    },
  };
 
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
    />
  );
}

// Komponent z powiązanymi usługami w tym samym mieście
function RelatedServices({ city, currentService }) {
  const relatedServices = services.filter(
    (s) => s.slug !== currentService.slug && s.category === currentService.category
  );
 
  return (
    <nav aria-label="Powiązane usługi">
      <h2>Inne przeglądy w {city.nameDeclension}</h2>
      <ul>
        {relatedServices.map((service) => (
          <li key={service.slug}>
            <a href={`/${city.slug}/${service.slug}`}>
              {service.name} {city.name}
            </a>
          </li>
        ))}
      </ul>
    </nav>
  );
}
 
// Komponent z tą samą usługą w pobliskich miastach
function NearbyCities({ service, currentCity }) {
  const nearby = cities
    .filter((c) => c.slug !== currentCity.slug)
    .filter((c) => c.voivodeship === currentCity.voivodeship)
    .slice(0, 5);
 
  return (
    <nav aria-label="Ta usługa w innych miastach">
      <h2>{service.name} w innych miastach</h2>
      <ul>
        {nearby.map((city) => (
          <li key={city.slug}>
            <a href={`/${city.slug}/${service.slug}`}>
              {service.name} {city.name}
            </a>
          </li>
        ))}
      </ul>
    </nav>
  );
}

// app/sitemap.ts
import { MetadataRoute } from 'next'
import cities from '@/data/cities.json'
import services from '@/data/services.json'
 
export default function sitemap(): MetadataRoute.Sitemap {
  const entries: MetadataRoute.Sitemap = []
 
  // Strona główna i statyczne
  entries.push({
    url: 'https://twojadomena.pl',
    lastModified: new Date(),
    changeFrequency: 'weekly',
    priority: 1.0,
  })
 
  // Strony programmatic
  for (const city of cities) {
    for (const service of services) {
      entries.push({
        url: `https://twojadomena.pl/${city.slug}/${service.slug}`,
        // Realna data ostatniej regeneracji treści, NIE new Date() z czasu builda —
        // inaczej sygnalizujesz Google, że wszystkie strony zmieniły się naraz przy każdym deployu
        lastModified: service.updatedAt ?? city.updatedAt,
        changeFrequency: 'monthly',
        priority: 0.7,
      })
    }
  }
 
  return entries
}