Discovery: Cache revalidation

.env.test

@@ -7,6 +7,8 @@ UNILOGIN_API_URL=https://et-broker.unilogin.dk
 UNILOGIN_CLIENT_ID=https://stg.ereolengo.itkdev.dk/
 UNILOGIN_CLIENT_SECRET=XXX
 UNILOGIN_SESSION_SECRET=XXX
+UNILOGIN_WELLKNOWN_URL=https://hi-i-am-well-known-url.com
 
 NEXT_PUBLIC_APP_URL=https://hellboy.the-movie.com
-UNILOGIN_WELLKNOWN_URL=https://hi-i-am-well-known-url.com
+
+REVALIDATE_CACHE_SECRET=i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=

__tests__/revalidating-cache.test.ts

@@ -0,0 +1,181 @@
+// @vitest-environment node
+import { testApiHandler } from "next-test-api-route-handler"
+import { revalidatePath, revalidateTag } from "next/cache"
+import { describe, test } from "vitest"
+
+// @ts-ignore
+import * as revalidateCacheHandler from "@/app/cache/revalidate/route"
+
+vi.mock("next/cache", () => ({
+  revalidatePath: vi.fn(),
+  revalidateTag: vi.fn(),
+}))
+
+beforeEach(() => {
+  // Mock the revalidatePath and revalidateTag functions
+  // @ts-ignore
+  revalidatePath.mockReturnValue(true)
+  // @ts-ignore
+  revalidateTag.mockReturnValue(true)
+})
+
+describe("Revalidate cache test access via bearer token", () => {
+  test("That the cache revalidation endpoint returns 401 if no bearer token is provided", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ type: "tag", tags: ["tag1", "tag2"] }),
+        })
+        expect(res.status).toBe(401)
+      },
+    })
+  })
+
+  test("That the cache revalidation endpoint returns 200 if a valid bearer token is provided", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "tag", tags: ["tag1", "tag2"] }),
+        })
+        expect(res.status).toBe(200)
+      },
+    })
+  })
+})
+
+describe("Revalidate cache test combination of payloads", () => {
+  test("That the cache revalidation endpoint returns 422 upon wrong input", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "unknown-type" }),
+        })
+        expect(res.status).toBe(422)
+      },
+    })
+
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "tag", theTags: ["tag1", "tag2"] }),
+        })
+        expect(res.status).toBe(422)
+      },
+    })
+  })
+
+  test("That the cache revalidation endpoint returns 200 upon successful tag invalidation", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "tag", tags: ["tag1", "tag2"] }),
+        })
+        expect(res.status).toBe(200)
+      },
+    })
+  })
+
+  test("That the cache revalidation endpoint returns 200 upon successful path invalidation", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "path", paths: ["/some/path", "/some/path"] }),
+        })
+        expect(res.status).toBe(200)
+      },
+    })
+  })
+})
+
+describe("Revalidate cache test different path and tag formats", async () => {
+  test("That the cache revalidation endpoint returns 422 if a wrongly formatted path is given", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "path", paths: ["some/path", "/some/path"] }),
+        })
+        expect(res.status).toBe(422)
+      },
+    })
+  })
+  test("That the cache revalidation endpoint returns 422 if a wrongly formatted path is given", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "path", paths: ["/some/*path", "/some/path"] }),
+        })
+        expect(res.status).toBe(422)
+      },
+    })
+  })
+  test("That the cache revalidation endpoint returns 422 if a wrongly formatted tag is given", async () => {
+    await testApiHandler({
+      appHandler: revalidateCacheHandler,
+      url: `/cache/revalidate`,
+      async test({ fetch }) {
+        const res = await fetch({
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer i9yUwqwgVLfvQ+4f8TnNRZcmHOYOKuUOTpZraUIWUCc=",
+          },
+          body: JSON.stringify({ type: "tag", paths: ["!wrong-tag", "another tag"] }),
+        })
+        expect(res.status).toBe(422)
+      },
+    })
+  })
+})

app/artikel/[...pathElements]/article.dpl-cms.graphql

@@ -0,0 +1,35 @@
+query getArticle($id: ID!) {
+  nodeArticle(id: $id) {
+    title
+    subtitle
+    paragraphs {
+      __typename
+      ... on ParagraphTextBody {
+        body {
+          value
+        }
+      }
+    }
+  }
+}
+
+query getArticleByRoute($path: String!) {
+  route(path: $path) {
+    ... on RouteInternal {
+      entity {
+        ... on NodeArticle {
+          title
+          subtitle
+          paragraphs {
+            __typename
+            ... on ParagraphTextBody {
+              body {
+                value
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

app/artikel/[...pathElements]/loadArticle.ts

@@ -0,0 +1,15 @@
+import { fetcher } from "@/lib/graphql/fetchers/dpl-cms.fetcher"
+import {
+  GetArticleByRouteDocument,
+  GetArticleByRouteQuery,
+} from "@/lib/graphql/generated/dpl-cms/graphql"
+
+const loadArticle = async (path: string) => {
+  const data = await fetcher<GetArticleByRouteQuery, { path: string }>(GetArticleByRouteDocument, {
+    path,
+  })()
+
+  return data
+}
+
+export default loadArticle

app/artikel/[...pathElements]/loadArticlesSsg.ts

@@ -0,0 +1,45 @@
+// import getQueryClient from "@/lib/getQueryClient"
+// import {
+//   ExtractArticlesQuery,
+//   useExtractArticlesQuery,
+// } from "@/lib/graphql/generated/dpl-cms/graphql"
+
+// const loadArticlesSsg = async () => {
+//   const queryClient = getQueryClient()
+//   const pageSize = 100
+//   // We have a while loop.
+//   // Just to be safe we do not allow more than 100 iterations.
+//   const maxRuns = 100
+//   let runNumber = 0
+
+//   const {
+//     nodeArticles: { nodes, edges, pageInfo },
+//   } = await queryClient.fetchQuery<ExtractArticlesQuery>({
+//     queryKey: useExtractArticlesQuery.getKey({ pageSize }),
+//     queryFn: useExtractArticlesQuery.fetcher({ pageSize }),
+//   })
+//   let allNodes = nodes
+//   let allEdges = edges
+//   let cursor = edges[edges.length - 1]?.cursor
+
+//   while (pageInfo.hasNextPage && runNumber < maxRuns) {
+//     const {
+//       nodeArticles: { nodes: newNodes, edges: newEdges },
+//     } = await queryClient.fetchQuery<ExtractArticlesQuery>({
+//       queryKey: useExtractArticlesQuery.getKey({ pageSize, cursor }),
+//       queryFn: useExtractArticlesQuery.fetcher({ pageSize, cursor }),
+//     })
+
+//     allNodes = [...allNodes, ...newNodes]
+//     allEdges = [...allEdges, ...newEdges]
+//     cursor = newEdges[newEdges.length - 1]?.cursor
+//     // eslint-disable-next-line no-console
+//     console.log({ allNodes, allEdges, cursor })
+
+//     runNumber += 1
+//   }
+
+//   return { nodes: allNodes }
+// }
+
+// export default loadArticlesSsg

app/artikel/[...pathElements]/page.tsx

@@ -0,0 +1,19 @@
+import loadArticle from "./loadArticle"
+
+// import loadArticlesSsg from "./loadArticlesSsg"
+
+const Page = async (props: { params: Promise<{ pathElements: string[] }> }) => {
+  const params = await props.params
+
+  const { pathElements } = params
+
+  const path = [...pathElements].join("/")
+  const data = await loadArticle(path)
+  return <pre>{JSON.stringify(data, null, 2)}</pre>
+}
+
+export default Page
+
+export async function generateStaticParams() {
+  return []
+}