@trieb.work/nextjs-turbo-redis-cache 1.18.0 → 1.18.1

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/api/revalidate.ts

@@ -1,24 +0,0 @@
-import type { NextApiRequest, NextApiResponse } from 'next';
-
-// On-demand revalidation endpoint: res.revalidate(path) re-renders the page
-// and writes the fresh entry through the cache handler, so all instances
-// sharing the same Redis pick it up.
-export default async function handler(
-  req: NextApiRequest,
-  res: NextApiResponse,
-) {
-  const path = req.query.path;
-  if (typeof path !== 'string') {
-    return res
-      .status(400)
-      .json({ revalidated: false, error: 'Missing ?path= query parameter' });
-  }
-  try {
-    await res.revalidate(path);
-    return res.json({ revalidated: true, path });
-  } catch (err) {
-    return res
-      .status(500)
-      .json({ revalidated: false, path, error: String(err) });
-  }
-}

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/index.tsx

@@ -1,11 +0,0 @@
-export default function Home() {
-  return (
-    <main>
-      <h1>Pages Router test app</h1>
-      <p>
-        Fixture for testing the Redis cache handler with the Next.js Pages
-        Router (PAGES, REDIRECT and notFound cache entries).
-      </p>
-    </main>
-  );
-}

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/isr/[slug].tsx

@@ -1,49 +0,0 @@
-import type { GetStaticPaths, GetStaticProps } from 'next';
-
-type Props = { slug: string; timestamp: number; counter: number };
-
-// Per-process regeneration counter. Two server instances of the same build
-// have independent counters, while the timestamp proves cross-instance
-// freshness after on-demand revalidation.
-let regenerationCounter = 0;
-
-export default function IsrPage({ slug, timestamp, counter }: Props) {
-  return (
-    <main>
-      <h1>ISR page</h1>
-      <p>Slug: {slug}</p>
-      <p>Timestamp: {timestamp}</p>
-      <p>Counter: {counter}</p>
-    </main>
-  );
-}
-
-export const getStaticPaths: GetStaticPaths = async () => {
-  return {
-    paths: [{ params: { slug: 'prebuilt' } }],
-    fallback: 'blocking',
-  };
-};
-
-// revalidate is set high (300s) so that natural ISR regeneration does not
-// interfere with the on-demand revalidation (res.revalidate) tests.
-export const getStaticProps: GetStaticProps<Props> = async (context) => {
-  const slug = context.params?.slug as string;
-
-  if (slug === 'not-found') {
-    return { notFound: true, revalidate: 300 };
-  }
-
-  if (slug === 'redirect') {
-    return {
-      redirect: { destination: '/static-forever', permanent: false },
-      revalidate: 300,
-    };
-  }
-
-  regenerationCounter += 1;
-  return {
-    props: { slug, timestamp: Date.now(), counter: regenerationCounter },
-    revalidate: 300,
-  };
-};

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/static-forever.tsx

@@ -1,20 +0,0 @@
-import type { GetStaticProps } from 'next';
-
-type Props = { timestamp: number };
-
-export default function StaticForever({ timestamp }: Props) {
-  return (
-    <main>
-      <h1>Static forever</h1>
-      <p>Timestamp: {timestamp}</p>
-    </main>
-  );
-}
-
-// revalidate is intentionally omitted (revalidate: false): the cache entry
-// must fall through to the defaultStaleAge based TTL in the cache handler.
-export const getStaticProps: GetStaticProps<Props> = async () => {
-  return {
-    props: { timestamp: Date.now() },
-  };
-};

package/test/nextjs-test-projects/next-pages-16-3-0/tsconfig.json

@@ -1,34 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2017",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "react-jsx",
-    "incremental": true,
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": [
-    "next-env.d.ts",
-    "**/*.ts",
-    "**/*.tsx",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts",
-    "**/*.mts"
-  ],
-  "exclude": ["node_modules"]
-}

package/test/playwright/cache-lab.spec.ts

@@ -1,232 +0,0 @@
-import { test, expect } from '@playwright/test';
-
-// These tests assume the Cache Components Next.js app is already running on the same origin as baseURL.
-// Recommended:
-//   PLAYWRIGHT_BASE_URL=http://localhost:3001 pnpm test:e2e
-
-test.describe('Cache Lab (Cache Components)', () => {
-  test('use cache non-deterministic values are stable until updateTag', async ({
-    page,
-  }) => {
-    await page.goto('/cache-lab/use-cache-nondeterministic');
-
-    const random1 = page.getByTestId('random1');
-    const now = page.getByTestId('now');
-
-    await expect(random1).toBeVisible();
-
-    const beforeRandom = await random1.textContent();
-    const beforeNow = await now.textContent();
-
-    await page.reload();
-    await expect(random1).toBeVisible();
-
-    const afterReloadRandom = await random1.textContent();
-    const afterReloadNow = await now.textContent();
-
-    expect(afterReloadRandom).toBe(beforeRandom);
-    expect(afterReloadNow).toBe(beforeNow);
-
-    await page
-      .getByRole('button', { name: "updateTag('cache-lab:nondet')" })
-      .click();
-    await page.waitForLoadState('networkidle');
-
-    await expect(random1).toBeVisible();
-
-    const afterInvalidateRandom = await random1.textContent();
-    const afterInvalidateNow = await now.textContent();
-
-    expect(afterInvalidateRandom).not.toBe(beforeRandom);
-    expect(afterInvalidateNow).not.toBe(beforeNow);
-  });
-
-  test('tag invalidation changes cached values (updateTag + revalidateTag)', async ({
-    page,
-  }) => {
-    await page.goto('/cache-lab/tag-invalidation');
-
-    const createdAt = page.getByTestId('createdAt');
-    const value = page.getByTestId('value');
-
-    await expect(createdAt).toBeVisible();
-
-    const beforeCreatedAt = await createdAt.textContent();
-    const beforeValue = await value.textContent();
-
-    await page.reload();
-    await expect(createdAt).toBeVisible();
-    expect(await createdAt.textContent()).toBe(beforeCreatedAt);
-    expect(await value.textContent()).toBe(beforeValue);
-
-    await page
-      .getByRole('button', { name: "updateTag('cache-lab:tag')" })
-      .click();
-    await page.waitForLoadState('networkidle');
-
-    await expect(createdAt).toBeVisible();
-    expect(await createdAt.textContent()).not.toBe(beforeCreatedAt);
-    expect(await value.textContent()).not.toBe(beforeValue);
-
-    const afterUpdateCreatedAt = await createdAt.textContent();
-    const afterUpdateValue = await value.textContent();
-
-    await page
-      .getByRole('button', { name: "revalidateTag('cache-lab:tag')" })
-      .click();
-    await page.waitForLoadState('networkidle');
-
-    await expect(createdAt).toBeVisible();
-
-    const maybeStaleCreatedAt = await createdAt.textContent();
-    const maybeStaleValue = await value.textContent();
-
-    // Revalidate can be SWR; allow either immediate refresh or stale served,
-    // but the value should eventually change on subsequent reloads.
-    if (maybeStaleCreatedAt === afterUpdateCreatedAt) {
-      // give background refresh some time
-      await page.waitForTimeout(4000);
-      await page.reload();
-      await expect(createdAt).toBeVisible();
-    }
-
-    expect(await createdAt.textContent()).not.toBe(afterUpdateCreatedAt);
-    expect(await value.textContent()).not.toBe(afterUpdateValue);
-  });
-
-  test('runtime cookie changes cache key (cached payload differs per cookie)', async ({
-    page,
-  }) => {
-    await page.goto('/cache-lab/runtime-data-suspense');
-
-    const cookieValue = page.getByTestId('cookie');
-    const payload = page.getByTestId('payload');
-
-    await expect(cookieValue).toBeVisible();
-
-    await page.getByRole('button', { name: 'Set cookie: user-a' }).click();
-    await page.waitForLoadState('networkidle');
-
-    await expect(cookieValue).toHaveText('user-a');
-    const payloadA1 = await payload.textContent();
-
-    await page.reload();
-    await expect(cookieValue).toHaveText('user-a');
-    const payloadA2 = await payload.textContent();
-    expect(payloadA2).toBe(payloadA1);
-
-    await page.getByRole('button', { name: 'Set cookie: user-b' }).click();
-    await page.waitForLoadState('networkidle');
-
-    await expect(cookieValue).toHaveText('user-b');
-    const payloadB = await payload.textContent();
-
-    expect(payloadB).not.toBe(payloadA1);
-  });
-
-  test('use cache: remote values are stable until updateTag', async ({
-    page,
-  }) => {
-    await page.goto('/cache-lab/use-cache-remote');
-
-    const computedAt = page.getByTestId('computedAt');
-    const value = page.getByTestId('value');
-
-    await expect(computedAt).toBeVisible();
-
-    const beforeComputedAt = await computedAt.textContent();
-    const beforeValue = await value.textContent();
-
-    await page.reload();
-    await expect(computedAt).toBeVisible();
-    expect(await computedAt.textContent()).toBe(beforeComputedAt);
-    expect(await value.textContent()).toBe(beforeValue);
-
-    await page
-      .getByRole('button', { name: "updateTag('cache-lab:remote')" })
-      .click();
-    await page.waitForLoadState('networkidle');
-
-    await expect(computedAt).toBeVisible();
-    expect(await computedAt.textContent()).not.toBe(beforeComputedAt);
-    expect(await value.textContent()).not.toBe(beforeValue);
-  });
-
-  test('revalidateTag with durations can serve stale values before refresh completes', async ({
-    page,
-  }) => {
-    await page.goto('/cache-lab/revalidate-durations');
-
-    const computedAt = page.getByTestId('computedAt');
-    const value = page.getByTestId('value');
-
-    await expect(computedAt).toBeVisible();
-
-    const beforeComputedAt = await computedAt.textContent();
-    const beforeValue = await value.textContent();
-
-    const actionResponse = page.waitForResponse(
-      (res) =>
-        res.request().method() === 'POST' &&
-        res.url().includes('/cache-lab/revalidate-durations'),
-    );
-    await page
-      .getByRole('button', {
-        name: "revalidateTag('cache-lab:durations', { expire: 2 })",
-      })
-      .click();
-    await actionResponse;
-
-    // Reload as soon as the Server Action has landed. Do not wait for
-    // networkidle — that can let the ~2.5s background refresh finish first.
-    await page.reload();
-    await expect(computedAt).toBeVisible();
-
-    const afterRevalidateComputedAt = await computedAt.textContent();
-    const afterRevalidateValue = await value.textContent();
-
-    // SWR: ideally the first reload still serves previous values. If background
-    // refresh already completed, skip the stale assertion and verify eventual refresh.
-    if (afterRevalidateComputedAt === beforeComputedAt) {
-      expect(afterRevalidateValue).toBe(beforeValue);
-    }
-
-    await page.waitForTimeout(5000);
-    await page.reload();
-    await expect(computedAt).toBeVisible();
-
-    expect(await computedAt.textContent()).not.toBe(beforeComputedAt);
-    expect(await value.textContent()).not.toBe(beforeValue);
-  });
-
-  test('stale-while-revalidate demo eventually produces a new value after revalidateTag', async ({
-    page,
-  }) => {
-    await page.goto('/cache-lab/stale-while-revalidate');
-
-    const computedAt = page.getByTestId('computedAt');
-    const value = page.getByTestId('value');
-
-    await expect(computedAt).toBeVisible();
-
-    const beforeComputedAt = await computedAt.textContent();
-    const beforeValue = await value.textContent();
-
-    // Ensure it becomes stale.
-    await page.waitForTimeout(3000);
-
-    await page
-      .getByRole('button', { name: "revalidateTag('cache-lab:swr')" })
-      .click();
-    await page.waitForLoadState('networkidle');
-
-    // Allow some time for background refresh to potentially complete.
-    await page.waitForTimeout(4500);
-
-    await page.reload();
-    await expect(computedAt).toBeVisible();
-
-    expect(await computedAt.textContent()).not.toBe(beforeComputedAt);
-    expect(await value.textContent()).not.toBe(beforeValue);
-  });
-});

package/test/playwright/update-tag.spec.ts

@@ -1,33 +0,0 @@
-import { test, expect } from '@playwright/test';
-
-// This test assumes the Next 16 app is already running, e.g.:
-//   cd test/nextjs-test-projects/next-app-16-0-11 && pnpm dev
-// on the same origin as baseURL.
-
-test('button click triggers Server Action using updateTag', async ({
-  page,
-}) => {
-  await page.goto('/update-tag-test');
-
-  await expect(page.getByText('UpdateTag Test')).toBeVisible();
-
-  const clicks = page.getByTestId('clicks');
-  const before = await clicks.textContent();
-
-  await page.getByRole('button', { name: 'Increment' }).click();
-
-  // Wait for network and any navigation caused by the Server Action
-  await page.waitForLoadState('networkidle');
-
-  const after = await clicks.textContent();
-
-  // Server Action should have run and updated the UI
-  expect(after).not.toBe(before);
-
-  // Ensure there is no error message about updateTag usage
-  const errorLocator = page.getByText(
-    'updateTag can only be called from within a Server Action',
-    { exact: false },
-  );
-  await expect(errorLocator).toHaveCount(0);
-});

package/test/vitest/integration/build-id-prefix.integration.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
-import { createClient, RedisClientType } from 'redis';
-import path from 'path';
-import fs from 'fs';
-import fetch from 'node-fetch';
-
-const NEXT_APP = 'next-app-15-4-11';
-const PORT = 3075;
-const BASE_URL = `http://localhost:${PORT}`;
-
-async function waitForServer(url: string, timeout = 20000) {
-  const start = Date.now();
-  while (Date.now() - start < timeout) {
-    try {
-      const res = await fetch(url + '/api/cached-static-fetch');
-      if (res.ok) return;
-    } catch {}
-    await new Promise((r) => setTimeout(r, 300));
-  }
-  throw new Error('Next.js server did not start in time');
-}
-
-describe('BUILD_ID-based key prefix (Next handlers)', () => {
-  let nextProcess: ChildProcessWithoutNullStreams | undefined;
-  let redis: RedisClientType;
-  let appDir: string;
-  let buildId: string;
-
-  beforeAll(async () => {
-    appDir = path.join(__dirname, '..', '..', 'nextjs-test-projects', NEXT_APP);
-
-    // Ensure clean env so BUILD_ID precedence kicks in
-    delete (process.env as Record<string, string | undefined>).KEY_PREFIX;
-    delete (process.env as Record<string, string | undefined>).VERCEL_URL;
-    process.env.VERCEL_ENV = 'production';
-    process.env.REDISHOST = process.env.REDISHOST || 'localhost';
-    process.env.REDISPORT = process.env.REDISPORT || '6379';
-
-    // Install + build
-    await new Promise<void>((resolve, reject) => {
-      const p = spawn('pnpm', ['install'], { cwd: appDir, stdio: 'inherit' });
-      p.on('close', (code) =>
-        code === 0 ? resolve() : reject(new Error('pnpm i failed')),
-      );
-    });
-    await new Promise<void>((resolve, reject) => {
-      const p = spawn('pnpm', ['build'], { cwd: appDir, stdio: 'inherit' });
-      p.on('close', (code) =>
-        code === 0 ? resolve() : reject(new Error('pnpm build failed')),
-      );
-    });
-
-    // Read BUILD_ID from the built app
-    buildId = fs
-      .readFileSync(path.join(appDir, '.next', 'BUILD_ID'), 'utf8')
-      .trim();
-
-    // Start server without KEY_PREFIX/VERCEL_URL
-    nextProcess = spawn('npx', ['next', 'start', '-p', String(PORT)], {
-      cwd: appDir,
-      env: { ...process.env, SKIP_KEYSPACE_CONFIG_CHECK: 'true' },
-      stdio: 'pipe',
-    });
-
-    nextProcess.stderr?.on(
-      'data',
-      (d) => process.env.DEBUG_INTEGRATION && console.error(String(d)),
-    );
-
-    await waitForServer(BASE_URL);
-
-    // Connect Redis
-    redis = createClient({
-      url: `redis://${process.env.REDISHOST}:${process.env.REDISPORT}`,
-    });
-    await redis.connect();
-  }, 180000);
-
-  afterAll(async () => {
-    try {
-      if (redis) await redis.quit();
-    } finally {
-      if (nextProcess) nextProcess.kill();
-    }
-  });
-
-  it('uses BUILD_ID as the Redis key prefix when no KEY_PREFIX/VERCEL_URL set', async () => {
-    // Warm cache twice to ensure a set occurs even if first was during startup
-    const res1 = await fetch(BASE_URL + '/api/cached-static-fetch');
-    expect(res1.ok).toBe(true);
-    await new Promise((r) => setTimeout(r, 500));
-    const res2 = await fetch(BASE_URL + '/api/cached-static-fetch');
-    expect(res2.ok).toBe(true);
-
-    // Allow background syncs
-    await new Promise((r) => setTimeout(r, 1500));
-
-    const keys = await redis.keys(`${buildId}*`);
-    expect(keys.length).toBeGreaterThan(0);
-  });
-});