@trieb.work/nextjs-turbo-redis-cache 1.17.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,157 +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('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);
-  });
-});

package/test/vitest/integration/cache-components/cache-components.integration.test.ts

@@ -1,231 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { spawn, ChildProcess } from 'child_process';
-import { createClient, RedisClientType } from 'redis';
-import path from 'path';
-
-const PORT = Number(process.env.CACHE_COMPONENTS_PORT || '3065');
-const BASE_URL = `http://localhost:${PORT}`;
-
-describe('Next.js 16 Cache Components Integration', () => {
-  let nextProcess: ChildProcess;
-  let redisClient: RedisClientType;
-  let keyPrefix: string;
-
-  async function delay(ms: number) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  beforeAll(async () => {
-    // Connect to Redis
-    redisClient = createClient({
-      url: process.env.REDIS_URL || 'redis://localhost:6379',
-      database: 1,
-    });
-    await redisClient.connect();
-
-    // Generate unique key prefix for this test run
-    keyPrefix = `cache-components-test-${Math.random().toString(36).substring(7)}`;
-    process.env.VERCEL_URL = keyPrefix;
-
-    const cacheComponentsApp =
-      process.env.CACHE_COMPONENTS_APP || 'next-app-16-2-6-cache-components';
-
-    const appDir = path.join(
-      __dirname,
-      '..',
-      '..',
-      '..',
-      'nextjs-test-projects',
-      cacheComponentsApp,
-    );
-
-    console.log('Installing Next.js app dependencies...');
-    await new Promise<void>((resolve, reject) => {
-      const installProcess = spawn('pnpm', ['install'], {
-        cwd: appDir,
-        stdio: 'inherit',
-      });
-
-      installProcess.on('close', (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`Install failed with code ${code}`));
-      });
-    });
-
-    console.log('Building Next.js app...');
-    await new Promise<void>((resolve, reject) => {
-      const buildProcess = spawn('pnpm', ['build'], {
-        cwd: appDir,
-        stdio: 'inherit',
-      });
-
-      buildProcess.on('close', (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`Build failed with code ${code}`));
-      });
-    });
-
-    console.log('Starting Next.js app...');
-    nextProcess = spawn('pnpm', ['start', '-p', PORT.toString()], {
-      cwd: appDir,
-      env: { ...process.env, VERCEL_URL: keyPrefix },
-    });
-
-    // Wait for server to be ready
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-  }, 120000);
-
-  afterAll(async () => {
-    // Clean up Redis keys
-    const keys = await redisClient.keys(`${keyPrefix}*`);
-    if (keys.length > 0) {
-      await redisClient.del(keys);
-    }
-    await redisClient.quit();
-
-    // Kill Next.js process
-    if (nextProcess) {
-      nextProcess.kill();
-    }
-  });
-
-  describe('Basic use cache functionality', () => {
-    it('should cache data and return same counter value on subsequent requests', async () => {
-      // First request
-      const res1 = await fetch(`${BASE_URL}/api/cached-static-fetch`);
-      const data1 = await res1.json();
-
-      expect(data1.counter).toBe(1);
-
-      // Second request should return cached data
-      const res2 = await fetch(`${BASE_URL}/api/cached-static-fetch`);
-      const data2 = await res2.json();
-
-      expect(data2.counter).toBe(1); // Same counter value
-      expect(data2.timestamp).toBe(data1.timestamp); // Same timestamp
-    });
-
-    it('should store cache entry in Redis', async () => {
-      await fetch(`${BASE_URL}/api/cached-static-fetch`);
-
-      // Check Redis for cache keys
-      const keys = await redisClient.keys(`${keyPrefix}*`);
-      expect(keys.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('cacheTag functionality', () => {
-    it('should cache data with tags', async () => {
-      const res1 = await fetch(`${BASE_URL}/api/cached-with-tag`);
-      const data1 = await res1.json();
-
-      expect(data1.counter).toBeDefined();
-
-      // Second request should return cached data
-      const res2 = await fetch(`${BASE_URL}/api/cached-with-tag`);
-      const data2 = await res2.json();
-
-      expect(data2.counter).toBe(data1.counter);
-    });
-
-    it('should invalidate cache when tag is revalidated (Stale while revalidate)', async () => {
-      // Get initial cached data
-      const res1 = await fetch(`${BASE_URL}/api/cached-with-tag`);
-      const data1 = await res1.json();
-
-      // Revalidate the tag
-      await fetch(`${BASE_URL}/api/revalidate-tag`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ tag: 'test-tag' }),
-      });
-
-      // The cache should be invalidated - verify by making multiple requests
-      // until we get fresh data (with retries for async revalidation)
-      let freshDataReceived = false;
-      // Next.js tag revalidation can be async and may take longer under some runtimes.
-      // Use a more tolerant window to avoid flaky failures.
-      for (let i = 0; i < 60; i++) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const res = await fetch(`${BASE_URL}/api/cached-with-tag`);
-        const data = await res.json();
-
-        if (
-          data.counter !== data1.counter ||
-          data.timestamp !== data1.timestamp
-        ) {
-          freshDataReceived = true;
-          break;
-        }
-      }
-
-      expect(freshDataReceived).toBe(true);
-    }, 20_000);
-  });
-
-  describe('cacheLife functionality', () => {
-    it('should respect expire window and eventually return refreshed data', async () => {
-      const res1 = await fetch(`${BASE_URL}/api/cached-with-cachelife`);
-      const data1 = await res1.json();
-      expect(data1.counter).toBe(1);
-
-      const res2 = await fetch(`${BASE_URL}/api/cached-with-cachelife`);
-      const data2 = await res2.json();
-      expect(data2.counter).toBe(data1.counter);
-      expect(data2.timestamp).toBe(data1.timestamp);
-
-      await delay(6500);
-
-      let refreshedData: any;
-      for (let i = 0; i < 10; i++) {
-        const res = await fetch(`${BASE_URL}/api/cached-with-cachelife`);
-        const data = await res.json();
-
-        if (
-          data.counter !== data1.counter ||
-          data.timestamp !== data1.timestamp
-        ) {
-          refreshedData = data;
-          break;
-        }
-
-        await delay(500);
-      }
-
-      expect(refreshedData).toBeDefined();
-      expect(refreshedData.counter).toBeGreaterThan(data1.counter);
-      expect(refreshedData.timestamp).not.toBe(data1.timestamp);
-    }, 20_000);
-  });
-
-  describe('Redis cache handler integration', () => {
-    it('should call cache handler get and set methods', async () => {
-      // Make request to trigger cache (don't clear first)
-      await fetch(`${BASE_URL}/api/cached-static-fetch`);
-
-      // Verify Redis has the cached data
-      const redisKeys = await redisClient.keys(`${keyPrefix}*`);
-      expect(redisKeys.length).toBeGreaterThan(0);
-
-      // Filter out hash keys (sharedTagsMap) and only check string keys (cache entries)
-      // Try to get each key and verify at least one is a string value
-      let foundStringKey = false;
-      for (const key of redisKeys) {
-        try {
-          const type = await redisClient.type(key);
-          if (type === 'string') {
-            const cachedValue = await redisClient.get(key);
-            if (cachedValue) {
-              foundStringKey = true;
-              expect(cachedValue).toBeTruthy();
-              break;
-            }
-          }
-        } catch (e) {
-          // Skip non-string keys
-        }
-      }
-      expect(foundStringKey).toBe(true);
-    });
-  });
-});