Support Next 15 - When?

[yuriyyakym]

Hey!

Is there a plan to release Next 15 support?
I see there is an open PR.

The code in the PR looks good, though not passing some tests.

We're using Next 15, so supporting rsc data was crucial for us.
For now I had to monkey-patch cacheHandler like this (inspired by the PR):

const { get: originalGet, set: originalSet } = redisHandler;

Object.assign(redisHandler, {
    async get(key, meta) {
        const cachedData = await originalGet(key, meta);

        if (cachedData?.value?.kind === 'APP_PAGE') {
            cachedData.value.rscData = Buffer.from(cachedData.value.rscData, 'base64');
        }

        if (cachedData?.value?.kind === 'ROUTE') {
            cachedData.value.body = Buffer.from(cachedData.value.body, 'base64');
        }

        return cachedData;
    },
    set(key, data) {
        return originalSet(key, {
            ...data,
            value: {
                ...data.value,
                rscData: data.value.rscData?.toString('base64'),
            },
        });
    },
});

It would be nice if you release the version with Next 15 support under some rc/beta tag.

[better-salmon]

Hey @yuriyyakym! Thank you for bringing up this topic. I appreciate your contribution and interest in adding support for Next.js 15.

I was waiting for the RC 1 of Next.js 15 to continue working on this pull request. I will check if the latest canary of the Next.js is passing tests.

Regarding your workaround, it's great that you've found one! @neshca/cache-handler was designed to be customizable, so it's a good practice to do so.

[ScreamZ]

RC is available yet, any news ?

[better-salmon]

The RC is still at 0. I'm monitoring the canary branch to stay updated and waiting for RC1.

[jakehopking]

I've been pulling my hair out thinking there was an issue with my code! So it's simply that there's no support for Next 15 yet. I'm running v15.0.0-canary.190.
@yuriyyakym Would you mind sharing your full example so I can see if it works for me too?

Thanks!

[yuriyyakym]

import { CacheHandler } from '@neshca/cache-handler';
import createRedisHandler from '@neshca/cache-handler/redis-stack';
import { createClient } from 'redis';

CacheHandler.onCreation(async () => {
    const client = createClient({ url: process.env.WEBSITE_CACHE_REDIS_URL });
    
    client.on('error', (err) => {
        console.error(err);
    });

    await client.connect();

    // create your redis handler
    const redisHandler = await createRedisHandler({
        client,
        timeoutMs: 5000,
        keyPrefix: process.env.WEBSITE_CACHE_REDIS_PREFIX ?? '',
    });

    // monkey-patch it with my suggestion
    const { get: originalGet, set: originalSet } = redisHandler;
    Object.assign(redisHandler, {
        async get(key, meta) {
            const cachedData = await originalGet(key, meta);

            if (cachedData?.value?.kind === 'APP_PAGE') {
                cachedData.value.rscData = Buffer.from(cachedData.value.rscData, 'base64');
            }

            if (cachedData?.value?.kind === 'ROUTE') {
                cachedData.value.body = Buffer.from(cachedData.value.body, 'base64');
            }

            return cachedData;
        },
        set(key, data) {
            return originalSet(key, {
                ...data,
                value: {
                    ...data.value,
                    rscData: data.value.rscData?.toString('base64'),
                },
            });
        },
    });

    return { handlers: [redisHandler] };    
});

export default CacheHandler;

[jakehopking]

Thank you so much for this @yuriyyakym!
Caching with redis now actually almost works... I no long get 500 errors and infinite page reloads!!! Your patch successfully revalidates my unstable_cache instances with revalidateTag.
It doesn't revalidate paths unfortunately, so I'm unable to use yet. Did you have have any success with that?

@better-salmon do you have any insights on why calling revalidatePath wouldn't invalidate the cache key here?

[jake-lantern]

The revalidatePath successfully creates a hash entry in redis:

But not much else happens as far as I can tell:
[CacheHandler] [method: revalidateTag] [tags: []] Started revalidating tag in parallel.

[jake-lantern]

@better-salmon RC1 has landed :) https://github.com/vercel/next.js/releases/tag/v15.0.0-rc.1

[ScreamZ]

Rc2

[jakehopking]

Next 15 is stable: https://github.com/vercel/next.js/releases/tag/v15.0.0

Looking forward to the update from @better-salmon 🙏

[better-salmon]

Hi everyone!

I’m currently working on supporting Next.js 15. It will take a bit of time, as there are many changes in Next.js, some of which are breaking. I aim to maintain backward compatibility as much as possible. I appreciate your patience during this process!

[jakehopking]

Thank you @better-salmon 🙏

[ScreamZ]

You could take inspiration from next-intl (and @amannn which is a really smart developer) and especially this amannn/next-intl#1383 which has migrated the whole API for NextJS 15

[better-salmon]

Just a quick update! Believe it or not, I somehow managed to catch Covid-19 in 2024. 😆

But I’m all better now and back to work! Made a new PR #846

[ScreamZ]

So it's Covid 24

[jinl0ng]

Are there any updates? I noticed there's a Next15 branch in the repository. Can we directly use this branch now to support Next.js 15? Thank you.

[jdpnielsen]

Echoing this. Let us know if we can help test things, @better-salmon

[studentIvan]

Please don't forget about us @better-salmon we pray for your health and next 15 support :)

[studentIvan]

For somebody who running this plugin under redis-strings and still getting 500 can be helpful #846 (comment)

[studentIvan]

Looks like this plugin is abandoned, anybody knows the good alternative?

[ScreamZ]

I don't think this is hard stuff to create a new driver, I'll work on it in the next year if NextJS team doesn't do something about it. The real hard stuff is the opaque naming for routes.

[JesperCph]

Hi @better-salmon,

I’m starting to worry this plugin might be abandoned. Next.js 15 support is clearly important to many here, and there’s been no update for a while. Could you let us know if this is still being actively worked on? If not, it would be great to know so the community can explore alternatives or step in.

Thanks!

[leoBergerot]

Hi everyone,

I also need support for Next 15. I use this one, and all my tests pass. Has anyone else tested this? → fortedigital/nextjs-cache-handler

If you’re interested, I can share my cache-handler.mjs file with the implementation of this dependency.

Thx

[Rikard-Johansson97]

@leoBergerot please share your cache-handler.mjs file :)

[leoBergerot]

import { CacheHandler } from "@neshca/cache-handler";
import bufferStringDecorator from "@fortedigital/nextjs-cache-handler/buffer-string-decorator";
import createLruHandler from "@neshca/cache-handler/local-lru";
import createHandler from "@fortedigital/nextjs-cache-handler/redis-strings";
import { createClient } from "redis";

CacheHandler.onCreation(async () => {
  let client;

  try {
    // Create a Redis client.
    client = createClient({
      url: process.env.NEXT_NODE_REDIS_URL ?? "redis://localhost:6379",
    });

    // Redis won't work without error handling.
    client.on("error", () => {});
  } catch (error) {
    console.warn("Failed to create Redis client:", error);
  }

  if (client) {
    try {
      console.info("Connecting Redis client...");

      // Wait for the client to connect.
      // Caveat: This will block the server from starting until the client is connected.
      // And there is no timeout. Make your own timeout if needed.
      await client.connect();
      console.info("Redis client connected.");
    } catch (error) {
      console.warn("Failed to connect Redis client:", error);

      console.warn("Disconnecting the Redis client...");
      // Try to disconnect the client to stop it from reconnecting.
      client
        .disconnect()
        .then(() => {
          console.info("Redis client disconnected.");
        })
        .catch(() => {
          console.warn(
            "Failed to quit the Redis client after failing to connect."
          );
        });
    }
  }

  /** @type {import("@neshca/cache-handler").Handler | null} */
  let handler;

  if (client?.isReady) {
    // Create the redis-strings Handler if the client is available and connected.
    handler = await bufferStringDecorator(
      createHandler({
        client,
        keyPrefix: process.env.NEXT_NODE_REDIS_PREFIX,
        sharedTagsKey: "TAGSKEY",
        sharedTagsTtlKey: "TagTtls",
        timeoutMs: 5000,
      })
    );
  } else {
    // Fallback to LRU handler if Redis client is not available.
    // The application will still work, but the cache will be in memory only and not shared.
    handler = createLruHandler();
    console.warn(
      "Falling back to LRU handler because Redis client is not available."
    );
  }

  return {
    handlers: [handler],
  };
});

[AdamZajler]

Hi everyone!

Does anyone have any information about when this package is planned to be updated to support Next 15.X? 😮

[06ketan]

Hi everyone,

I'm currently working with Next.js 15.3.1 and have integrated the following dependencies:

"redis": "^4.7.0"

"@neshca/cache-handler": "^1.9.0"​

With the configuration below, I can successfully set and get cache values. However, I'm encountering issues with cache revalidation.​

/* eslint-disable @typescript-eslint/no-require-imports */
const { CacheHandler } = require("@neshca/cache-handler");
const createClusterHandler =
  require("@neshca/cache-handler/experimental-redis-cluster").default;
const { createCluster } = require("redis");
const { PHASE_PRODUCTION_BUILD } = require("next/constants");

/* from https://caching-tools.github.io/next-shared-cache/redis */
CacheHandler.onCreation(async () => {
  let cluster;
  // Use redis cluster during build could cause issue https://github.com/caching-tools/next-shared-cache/issues/284#issuecomment-1919145094
  if (PHASE_PRODUCTION_BUILD !== process.env.NEXT_PHASE) {
    try {
      // Use REDIS_CLUSTER_URLS env var (comma-separated URLs) for cluster, else REDIS_URL for single node, else default to localhost:6379
      const clusterUrls = process.env.REDIS_CLUSTER_URLS
        ? process.env.REDIS_CLUSTER_URLS.split(",").map((url) => {
            return { url: url.trim() };
          })
        : null;

      if (clusterUrls && clusterUrls.length > 1) {
        // Use cluster mode for multiple Redis nodes
        console.info("Using Redis cluster mode with multiple nodes");
        cluster = createCluster({
          rootNodes: clusterUrls,
        });

        // Redis won't work without error handling.
        cluster.on("error", (e) => {
          console.error("Redis cluster error:", e);
          throw e;
        });
      }

      // Error handlers are now set up within the connection creation blocks
    } catch (error) {
      console.warn("Failed to create Redis cluster:", error);
    }
  }

  // Connect to Redis
  if (cluster) {
    try {
      console.info("Connecting Redis cluster...");

      // Wait for the cluster to connect.
      // Caveat: This will block the server from starting until the cluster is connected.
      // And there is no timeout. Make your own timeout if needed.
      await cluster.connect();
      console.info("Redis cluster connected.");
    } catch (error) {
      console.warn("Failed to connect Redis cluster:", error);

      console.warn("Disconnecting the Redis cluster...");
      // Try to disconnect the cluster to stop it from reconnecting.
      cluster
        .disconnect()
        .then(() => {
          console.info("Redis cluster disconnected.");
        })
        .catch(() => {
          console.warn(
            "Failed to quit the Redis cluster after failing to connect."
          );
        });

      // Set cluster to null so we don't try to use it
      cluster = null;
    }
  }

  /** @type {import("@neshca/cache-handler").Handler | null} */
  let redisHandler = null;

  if (cluster) {
    redisHandler = createClusterHandler({
      keyPrefix: "my-app-cache:",
      sharedTagsKey: "_sharedTags_",
      timeoutMs: 1000,
      cluster,
    });
  }

  return {
    handlers: [redisHandler],
  };
});

module.exports = CacheHandler;

I'm seeking a temporary workaround for cache revalidation until version 2.0.0 of @neshca/cache-handler is released. Any guidance or suggestions would be greatly appreciated.​

Thank you!

[06ketan]

@better-salmon @leoBergerot @yuriyyakym @studentIvan @jakehopking @ScreamZ @jdpnielsen