On-Demand Revalidation

// src/blog/server-functions.ts
"use server";

import { revalidatePage } from "dinou/server";
import db from "@/lib/db";

export async function updateArticle(slug: string, newContent: string) {
  await db.articles.update({
    where: { slug },
    data: { content: newContent, updatedAt: new Date() },
  });

  // Regenerates ONLY page.rsc and index.html for this blog post
  // Parent layout.rsc is NOT touched!
  await revalidatePage(`/blog/${slug}`);
}

// src/dashboard/server-functions.ts
"use server";

import { revalidatePath } from "dinou/server";

export async function updateDashboardNavigation() {
  // Revalidates /dashboard and cascades revalidatePage to ALL child routes
  await revalidatePath("/dashboard", { cascade: true });
}

// src/products/server-functions.ts
"use server";

import { revalidatePath, revalidatePage } from "dinou/server";
import db from "@/lib/db";

export async function updateCategory(categoryId: string, data: any) {
  await db.categories.update({ where: { id: categoryId }, data });

  // 1. Absolute path: Revalidates /catalog (page.rsc, index.html, layout.rsc)
  await revalidatePath("/catalog");

  // 2. Relative paths inside Server Functions (resolved via HTTP referer):
  // Revalidate the current invoking leaf page surgically (e.g. /catalog/edit)
  await revalidatePage("./");

  // Revalidate an adjacent route segment (e.g. /catalog/featured)
  await revalidatePath("../featured");
}

// Inside any page or layout Server Component:
import { Suspense } from "react";
import { DinouCacheSlot } from "dinou/server";
import { TrendingProducts, TrendingSkeleton } from "@/components/trending";

<Suspense fallback={<TrendingSkeleton />}>
  <DinouCacheSlot id="trending-grid" tag="trending" revalidate={600}>
    <TrendingProducts />
  </DinouCacheSlot>
</Suspense>

// In your Server Function:
"use server";

import { revalidateTag } from "dinou/server";

export async function refreshTrends() {
  await revalidateTag("trending");
  // Only the <TrendingProducts> slot payload is purged; the parent page stays cached!
}

import { Link } from "dinou";

// Clicking this link deletes pageCache for /feed before navigating,
// guaranteeing a real HTTP request to fetch fresh data from the server.
<Link href="/feed" fresh>
  View Latest Feed
</Link>

"use client";

import { useRouter } from "dinou";

export function RefreshControl() {
  const router = useRouter();

  // 1. Standard Soft Refresh (Default)
  // Clears only pageCache; leaves layoutCache intact (1 network request, 0 layout flicker)
  const handlePageRefresh = () => {
    router.refresh();
  };

  // 2. Full Refresh (Including Layout Shell)
  // Clears pageCache AND purges active layoutCache (fetches both fresh layout & page)
  const handleGlobalRefresh = () => {
    router.refresh({ layout: true });
  };

  return (
    <div className="flex gap-2">
      <button onClick={handlePageRefresh}>Refresh Page</button>
      <button onClick={handleGlobalRefresh}>Refresh All (Shell + Page)</button>
    </div>
  );
}

"use client";

import { refreshSlot, useRouter } from "dinou";

export function LiveAnalyticsButton() {
  const router = useRouter();

  const handleUpdate = () => {
    // 1. Direct standalone function:
    refreshSlot("analytics-summary", { fresh: true });

    // 2. Or via router instance (identical signature and options):
    // router.refreshSlot("analytics-summary", { fresh: true });
  };

  return <button onClick={handleUpdate}>Live Refresh Metrics</button>;
}

// dinou.config.mjs
import { defineConfig } from "dinou";
import { RedisStorage } from "dinou/server";
import { createClient } from "redis";

const redis = createClient({ url: process.env.REDIS_URL });
await redis.connect();

export default defineConfig({
  // Cluster-wide distributed cache storage for ISR and revalidation
  storage: new RedisStorage(redis, "dinou-cache:"),
});