Setter ttl

Author: anders-nom

.env.development

@@ -2,7 +2,6 @@ NODE_ENV=development
 ENV=localhost
 SERVICE_SECRET=dummyToken
 DOCKER_HOST_ADDRESS=host.docker.internal
-PAGE_CACHE_DIR=./.next/page-cache
 IMAGE_CACHE_DIR=./.next/image-cache
 ADMIN_ORIGIN=http://localhost:8080
 APP_ORIGIN=http://localhost:3000

.env.prod-local

@@ -2,7 +2,6 @@ NODE_ENV=production
 ENV=localhost
 SERVICE_SECRET=dummyToken
 DOCKER_HOST_ADDRESS=host.docker.internal
-PAGE_CACHE_DIR=./.next/page-cache
 IMAGE_CACHE_DIR=./.next/image-cache
 ADMIN_ORIGIN=http://localhost:8080
 APP_ORIGIN=http://localhost:3000

.github/workflows/build-image.yml

@@ -94,7 +94,6 @@ jobs:
           INNLOGGINGSSTATUS_URL=${{ inputs.INNLOGGINGSSTATUS_URL }}
           NAVNO_API_URL=${{ inputs.NAVNO_API_URL }}
           ASSET_PREFIX=https://cdn.nav.no/personbruker/nav-enonicxp-frontend
-          PAGE_CACHE_DIR=/tmp/pages
           IMAGE_CACHE_DIR=/tmp/images
           EOF
       - name: Nextjs cache

server/cache/custom-cache-handler.ts

@@ -2,13 +2,15 @@ import FileSystemCache from 'next/dist/server/lib/incremental-cache/file-system-
 import { LRUCache } from 'lru-cache';
 import { CacheHandlerValue } from 'next/dist/server/lib/incremental-cache';
 import { nodeFs } from 'next/dist/server/lib/node-fs-methods';
-import { redisClient } from './redis';
+import { RedisCache } from './redis';
 
 type FileSystemCacheContext = ConstructorParameters<typeof FileSystemCache>[0];
 
 const CACHE_TTL_24_HOURS = 3600 * 24 * 1000;
 
-const isrMemoryCache = new LRUCache<string, CacheHandlerValue>({
+export const redisCache = new RedisCache({ ttl: CACHE_TTL_24_HOURS });
+
+const localCache = new LRUCache<string, CacheHandlerValue>({
     max: 1000,
     ttl: CACHE_TTL_24_HOURS,
     ttlResolution: 1000,
@@ -33,9 +35,7 @@ export default class CustomFileSystemCache extends FileSystemCache {
     public async get(...args: Parameters<FileSystemCache['get']>) {
         const [key] = args;
 
-        console.log(`Getting from cache: ${key}`);
-
-        const foundData = await redisClient.get(key);
+        const foundData = await redisCache.get(key);
 
         if (!foundData?.value) {
             return null;
@@ -69,26 +69,26 @@ export default class CustomFileSystemCache extends FileSystemCache {
     public async set(...args: Parameters<FileSystemCache['set']>) {
         const [key, data] = args;
 
-        console.log(`Storing in cache: ${key}`);
-
         const cacheItem: CacheHandlerValue = {
             value: data,
             lastModified: Date.now(),
         };
 
-        redisClient.set(key, cacheItem);
+        redisCache
+            .set(key, cacheItem)
+            .then((result) => console.log(`Set key ${key} result`, result));
 
         // isrMemoryCache.set(key, { value: data, lastModified: Date.now() });
         // return super.set(...args);
     }
 
     public async clearGlobalCache() {
-        isrMemoryCache.clear();
+        localCache.clear();
         return true;
     }
 
     public async deleteGlobalCacheEntry(path: string) {
         const pagePath = path === '/' ? '/index' : path;
-        return isrMemoryCache.delete(pagePath);
+        return localCache.delete(pagePath);
     }
 }

server/cache/redis.ts

@@ -5,9 +5,9 @@ type AppEnv = typeof process.env.ENV;
 
 const clientOptions: { [key in AppEnv]?: RedisClientOptions } = {
     localhost: {
-        url: process.env.REDIS_URI_PAGECACHE_DEV1,
-        username: process.env.REDIS_USERNAME_PAGECACHE_DEV1,
-        password: process.env.REDIS_PASSWORD_PAGECACHE_DEV1,
+        url: process.env.REDIS_URI_PAGECACHE,
+        username: process.env.REDIS_USERNAME_PAGECACHE,
+        password: process.env.REDIS_PASSWORD_PAGECACHE,
     },
     dev1: {
         url: process.env.REDIS_URI_PAGECACHE_DEV1,
@@ -16,10 +16,15 @@ const clientOptions: { [key in AppEnv]?: RedisClientOptions } = {
     },
 };
 
-class RedisClient {
+type ConstructorProps = {
+    ttl: number;
+};
+
+export class RedisCache {
     private readonly client: ReturnType<typeof createClient>;
+    private readonly ttl: number;
 
-    constructor() {
+    constructor({ ttl }: ConstructorProps) {
         const options = clientOptions[process.env.ENV];
 
         if (!options) {
@@ -28,6 +33,8 @@ class RedisClient {
             );
         }
 
+        this.ttl = ttl;
+
         this.client = createClient(options)
             .on('connect', () => {
                 console.log('Redis client connected');
@@ -70,12 +77,8 @@ class RedisClient {
     }
 
     public async set(key: string, data: CacheHandlerValue) {
-        console.log(`Setting data for ${key}`);
-
-        const result = await this.client.set(key, JSON.stringify(data));
-
-        console.log(`Set key ${key} result`, result);
+        return this.client.set(key, JSON.stringify(data), {
+            EX: this.ttl,
+        });
     }
 }
-
-export const redisClient = new RedisClient();

server/server-setup.ts

@@ -8,7 +8,7 @@ import { setCacheKey } from './req-handlers/set-cache-key';
 import { handleInvalidateAllReq } from './req-handlers/invalidate-all';
 import { handleGetPendingResponses } from './req-handlers/pending-responses';
 import { serverSetupDev } from './server-setup-dev';
-import { redisClient } from './cache/redis';
+import { redisCache } from './cache/custom-cache-handler';
 
 // Set the no-cache header on json files from the incremental cache to ensure
 // data requested during client side navigation is always validated if cached
@@ -28,7 +28,7 @@ export const serverSetup = async (expressApp: Express, nextApp: NextServer) => {
     const nextServer = await getNextServer(nextApp);
     const currentBuildId = getNextBuildId(nextServer);
 
-    await redisClient.init();
+    await redisCache.init();
 
     console.log(`Current build id: ${currentBuildId}`);
 

src/nodeenv.d.ts

@@ -12,7 +12,6 @@ declare global {
             SERVICE_SECRET: string;
             REVALIDATOR_PROXY_ORIGIN: string;
             INNLOGGINGSSTATUS_URL: string;
-            PAGE_CACHE_DIR: string;
             IMAGE_CACHE_DIR: string;
             FAILOVER_ORIGIN: string;
             IS_FAILOVER_INSTANCE: string;