node node_modules/next-pwa-pack/scripts/copy-pwa-files.mjs
# или
npx next-pwa-pack/scripts/copy-pwa-files.mjs

"use server";
export async function revalidatePWA(urls: string[]) {
 const baseUrl = process.env.NEXT_PUBLIC_HOST || "http://localhost:3000";
 const res = await fetch(`${baseUrl}/api/pwa/revalidate`, {
   method: "POST",
   headers: { "Content-Type": "application/json" },
   body: JSON.stringify({
     urls,
     secret: process.env.REVALIDATION_SECRET,
   }),
 });
 return res.json();
}

node node_modules/next-pwa-pack/scripts/copy-pwa-server-actions.mjs

{
 "name": "Моё приложение",
 "short_name": "Моё приложение",
 "description": "Описание моего приложения",
 "start_url": "/",
 "display": "standalone",
 "background_color": "#ffffff",
 "theme_color": "#000000",
 "icons": [
   {
     "src": "/icons/icon-192x192.png",
     "sizes": "192x192",
     "type": "image/png"
   },
   {
     "src": "/icons/icon-512x512.png",
     "sizes": "512x512",
     "type": "image/png"
   }
 ]
}

import { PWAProvider } from "next-pwa-pack";


export default function layout({ children }) {
 return <PWAProvider>{children}</PWAProvider>;
}

// /middleware.ts
import { withPWA } from "next-pwa-pack/hoc/withPWA";


function originalMiddleware(request) {
 // ...ваша логика
 return response;
}


export default withPWA(originalMiddleware, {
 revalidationSecret: process.env.REVALIDATION_SECRET!,
 sseEndpoint: "/api/pwa/cache-events",
 webhookPath: "/api/pwa/revalidate",
});


export const config = {
 matcher: ["/", "/(ru|en)/:path*", "/api/pwa/:path*"],
};
```


**Аргументы хока:**


- `originalMiddleware` — ваша функция middleware (например, для i18n, авторизации и т.д.)
- `revalidationSecret` — секрет для авторизации запросов на ревалидацию, нужен, чтобы никто кроме вас не мог в него стучаться
- `sseEndpoint` — endpoint для SSE-событий (по умолчанию `/api/pwa/cache-events`), измените его, если данный роут уже занят вашим приложением
- `webhookPath` — endpoint для webhook-ревалидации (по умолчанию `/api/pwa/revalidate`), по нему методом POST можно осуществлять ревалидацию кеша на сервере или извне, так же на нем завязана функция revalidatePWA


**Важно:**
В `config.matcher` обязательно укажите пути, которые должны обрабатываться этим middleware (например, корень сайта, локализованные маршруты и PWA endpoints).

import { PWAProvider } from "next-pwa-pack";


export default function layout({ children }) {
 return <PWAProvider devMode>{children}</PWAProvider>;
}

import { PWAProvider } from "next-pwa-pack";


export default function layout({ children }) {
 return <PWAProvider swPath="/some-path/sw.js">{children}</PWAProvider>
;
}

export default withPWA(originalMiddleware, {
 revalidationSecret: process.env.REVALIDATION_SECRET!,
 sseEndpoint: "/api/pwa/cache-events",
 webhookPath: "/api/pwa/revalidate",
});


- `originalMiddleware` — ваша функция middleware (например, для i18n, авторизации и т.д.)
- `revalidationSecret` — секрет для авторизации запросов на ревалидацию, нужен, чтобы никто кроме вас не мог в него стучаться
- `sseEndpoint` — endpoint для SSE-событий (по умолчанию `/api/pwa/cache-events`), измените его, если данный роут уже занят вашим приложением
- `webhookPath` — endpoint для webhook-ревалидации (по умолчанию `/api/pwa/revalidate`), по нему методом POST можно осуществлять ревалидацию кеша на сервере или извне, так же на нем завязана функция revalidatePWA

import { updateSWCache } from "next-pwa-pack";


// После успешного создания поста
const handleCreatePost = async (data) => {
 await createPost(data);
 // Обновляем кэш вкладок с блогом и дашбордом
 updateSWCache(["/blog", "/dashboard"]);
};

import { revalidatePWA } from "../actions";


await createPost(data);
await revalidatePWA(["/my-page"]);

import { clearAllCache } from "next-pwa-pack";


const handleLogout = async () => {
 await logout();
 await clearAllCache(); // Очищаем все кэши
 router.push("/login");
};

import { usePWAStatus } from "next-pwa-pack";


function UpdateNotification() {
 const { hasUpdate, update } = usePWAStatus();
  if (hasUpdate) {
   return (
     <div className="update-banner">
       <p>Доступна новая версия приложения</p>
       <button onClick={update}>Обновить</button>
     </div>
   );
 }
  return null;
}

import {
 clearAllCache,
 reloadServiceWorker,
 updatePageCache,
 unregisterServiceWorkerAndClearCache,
 updateSWCache,
 disablePWACache,
 enablePWACache,
clearStaticCache,
 usePWAStatus,
} from "next-pwa-pack";


// Очищает все кэши, связанные с сервис-воркером.
await clearAllCache();


// Перезагружает сервис-воркер и обновляет страницу.
await reloadServiceWorker();


// Обновляет кэш для указанной страницы (или текущей, если не указано).
await updatePageCache("/about");


// Отключает сервис-воркер и очищает кэш.
await unregisterServiceWorkerAndClearCache();


// Запускает сигнал для всех вкладок и обновляет кэш в текущей вкладке.
// Может быть вызван после revalidateTag на клиенте.


// Сбрасывает кэш статических данных и API-ответов.
await clearStaticCache();


updateSWCache(["/page1", "/page2"]);


// Глобально отключает кэш PWA (до перезагрузки или вызова enablePWACache).
disablePWACache();


// Глобально включает кэш PWA (после вызова disablePWACache).
enablePWACache();


const { online, hasUpdate, swInstalled, update } = usePWAStatus();
// - `online` — онлайн/оффлайн статус
// - `hasUpdate` — доступно ли обновление
// - `swInstalled` — установлен ли сервис-воркер
// - `update()` — активировать новую версию приложения

// app/api/webhook/revalidate/route.ts


import { NextRequest, NextResponse } from "next/server";
import { revalidatePWA } from "@/app/actions";
import { revalidateTag } from "next/cache";


import { FetchTags } from "@/app/api/endpoints/backend";


interface RevalidateRequest {
 tags?: string[];
 secret: string;
 urls?: string[];
}


interface RevalidateResponse {
 success: boolean;
 message: string;
 tagsRevalidated: boolean;
 urlsRevalidated: boolean;
 tags: string[];
 urls: string[];
 successful: number;
 failed: number;
 timestamp: string;
}


export async function POST(request: NextRequest) {
 try {
   const { tags, secret, urls }: RevalidateRequest = await request.json();


   if (secret !== process.env.REVALIDATION_SECRET) {
     return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
   }


   let successful = 0;
   let failed = 0;
   let tagsRevalidated = false;
   let urlsRevalidated = false;
   const validTags = Object.values(FetchTags);
   const invalidTags =
     tags?.filter((tag) => !validTags.includes(tag as any)) || [];


   if (invalidTags.length > 0) {
     return NextResponse.json(
       { error: `Invalid tags: ${invalidTags.join(", ")}` },
       { status: 400 }
     );
   }


   if (tags && tags.length > 0) {
     const tagResults = await Promise.allSettled(
       tags.map((tag) => revalidateTag(tag as FetchTags))
     );
     successful = tagResults.filter((r) => r.status === "fulfilled").length;
     failed = tagResults.filter((r) => r.status === "rejected").length;
     tagsRevalidated = true;
   }


   if (urls && urls.length > 0) {
     await revalidatePWA(urls);
     urlsRevalidated = true;
   }


   const response: RevalidateResponse = {
     success: true,
     message: "Cache revalidation completed",
     tagsRevalidated,
     urlsRevalidated,
     tags: tags || [],
     urls: urls || [],
     successful,
     failed,
     timestamp: new Date().toISOString(),
   };


   return NextResponse.json(response);
 } catch (error) {
   console.error("Webhook revalidation error:", error);
   return NextResponse.json(
     { error: "Internal server error" },
     { status: 500 }
   );
 }
}

POST:  https://my-app(или localhost:3000)/api/webhook/revalidate


body: {
 "tags": ["faq"],
 "secret": "1234567890",
 "urls": ["/ru/question-answer"]
}


response: {
 "success": true,
 "message": "Cache revalidation completed",
 "tagsRevalidated": true,
 "urlsRevalidated": true,
 "tags": [
   "faq"
 ],
 "urls": [
   "/ru/question-answer"
 ],
 "successful": 1,
 "failed": 0,
 "timestamp": "2025-07-21T12:43:47.819Z"
}

export default function PWAProvider({
 children,
 swPath,
 devMode = false,
 serverRevalidation = { enabled: true, sseEndpoint: "/api/pwa/cache-events" },
}: PWAProviderProps) {