Skip to main content

Cache helper

Cache helper lets you build a more performant app by reducing the number of server side calls for the same data. You can create a short-term cache that stores JSON objects in your Devvit app for a limited amount of time. This is valuable when you have many clients trying to get the same data, for example a stock ticker value or a sports score.

Under the covers, it's Redis plus a local in-memory write-through cache. This provides a pattern for fetching data without involving a scheduler and allows small time-to-live (TTL, ~1 second). Cache helper lets the app make one request for the data, save the response, and provide this response to all users requesting the same data.

warning

Do not cache sensitive information. Cache helper randomly selects one user to make the real request and saves the response to the cache for others to use. You should only use cache helper for non-personalized fetches, since the same response is available to all users.

Usage​

You can import cache helper from @devvit/web/server in your server source files. The cache helper is not available client-side, so you will see an error if you try to import it in client source files.

import { cache } from '@devvit/web/server';

Parameters​

The cache takes a key and a TTL regardless of whether you are using Devvit Web or Devvit Blocks. The only difference is that the TTL is in seconds for Devvit Web and milliseconds for Devvit Blocks / Mod Tools.

ParametersDescription
keyThis is a string that identifies a cached response. Instead of making a real request, the app gets the cached response with the key you provide. Make sure to use different keys for different data. For example, if you’re saving post-specific data, add the postId to the cache key, like this: post_data_${postId}).
ttlTime to live is the number of seconds the cached response is expected to be relevant. Once the cached response expires, it will be voided and a real request is made to populate the cache again. You can treat it as a threshold, where ttl of 30 would mean that a request is done no more than once per 30 seconds.

Example​

Here’s a way to set up in-app caching instead of using scheduler or interval to fetch.

server/index.ts
import { Hono } from 'hono';
import { cache, context, createServer, getServerPort, reddit } from '@devvit/web/server';

type SubredditResponse = {
  type: 'subreddit';
  subreddit: string;
};

type SubredditErrorResponse = {
  status: 'error';
  message: string;
};

const app = new Hono();

app.get('/api/subreddit', async (c) => {
  const { postId } = context;

  if (!postId) {
    console.error('API Subreddit Error: postId not found in devvit context');
    return c.json<SubredditErrorResponse>(
      {
        status: 'error',
        message: 'postId is required but missing from context',
      },
      400
    );
  }

  try {
    const subredditName = await cache(
      async () => {
        const subreddit = await reddit.getCurrentSubreddit();
        if (!subreddit) {
          throw new Error('Subreddit is required but missing from context');
        }
        return subreddit.name;
      },
      {
        key: 'current_subreddit',
        ttl: 24 * 60 * 60, // expire after one day.
      }
    );
    console.log(`Current subreddit: ${subredditName}`);

    return c.json<SubredditResponse>({
      type: 'subreddit',
      subreddit: subredditName,
    });
  } catch (error) {
    console.error(`API Subreddit Error for post ${postId}:`, error);
    let errorMessage = 'Unknown error during subreddit retrieval';
    if (error instanceof Error) {
      errorMessage = `Subreddit retrieval failed: ${error.message}`;
    }
    return c.json<SubredditErrorResponse>({ status: 'error', message: errorMessage }, 400);
  }
});

const server = createServer(app);
server.on('error', (err) => console.error(`server error; ${err.stack}`));
server.listen(getServerPort());