FLS-1452 - Refactor AdapterCacheService to reduce duplicate code

wjrm500 · wjrm500 · commit 0d8d2908f44b · 2025-09-11T19:27:31.000+01:00
Currently in AdapterCacheService we have a lot of duplicate code, specifically around (A) supporting both in-memory caching of forms configurations, as well as caching via Redis, and (B) Redis client configuration for both forms configurations and session management.

In the case of (A), we handle this by using a new formStorage attribute. In the case of (B), we handle this by creating a new createRedisClient utility function.
diff --git a/runner/src/server/plugins/engine/MainPlugin.ts b/runner/src/server/plugins/engine/MainPlugin.ts
@@ -18,7 +18,7 @@ export const plugin = {
         let countError = 0;
         for (const config of configs) {
             try {
-                await adapterCacheService.setFormConfiguration(config.id, config, server);
+                await adapterCacheService.setFormConfiguration(config.id, config);
                 countOk++;
             } catch (e) {
                 countError++;
diff --git a/runner/src/server/services/AdapterCacheService.ts b/runner/src/server/services/AdapterCacheService.ts
@@ -15,8 +15,6 @@ import Crypto from 'crypto';
 import {HapiRequest, HapiServer} from "../types";
 import {AdapterFormModel} from "../plugins/engine/models";
 import Boom from "boom";
-import {FormConfiguration} from "@xgovformbuilder/model";
-import {AdapterSchema} from "@communitiesuk/model";
 
 const partition = "cache";
 const LOGGER_DATA = {
@@ -42,23 +40,43 @@ enum ADDITIONAL_IDENTIFIER {
     Confirmation = ":confirmation",
 }
 
+const createRedisClient = (): Redis | null => {
+   if (redisHost || redisUri) {
+       const redisOptions: {password?: string; tls?: {};} = {};
+       if (redisPassword) redisOptions.password = redisPassword;
+       if (redisTls) redisOptions.tls = {};
+       
+       return isSingleRedis
+           ? new Redis(redisUri ?? {host: redisHost, port: redisPort, password: redisPassword})
+           : new Redis.Cluster(
+               [{host: redisHost, port: redisPort}],
+               {dnsLookup: (address, callback) => callback(null, address, 4), redisOptions}
+           );
+   }
+   return null;
+};
+
 export class AdapterCacheService extends CacheService {
+    private formStorage: Redis | any;
 
     constructor(server: HapiServer) {
         //@ts-ignore
         super(server);
-        //@ts-ignore
-        server.app.redis = this.getRedisClient()
-        //@ts-ignore
-        if (!server.app.redis) {
-            // starting up the in memory cache
+        const redisClient = this.getRedisClient();
+        if (redisClient) {
+            this.formStorage = redisClient;
+        } else {
+            // Starting up the in memory cache
             this.cache.client.start();
-            //@ts-ignore
-            server.app.inMemoryFormKeys = []
+            this.formStorage = {
+                get: (key) => this.cache.get(key),
+                set: (key, value) => this.cache.set(key, value, {expiresIn: 0}),
+                setex: (key, ttl, value) => this.cache.set(key, value, {expiresIn: ttl}),
+            }
         }
     }
 
-    async activateSession(jwt, request) {
+    async activateSession(jwt, request): Promise<{ redirectPath: string }> {
         request.logger.info(`[ACTIVATE-SESSION] jwt ${jwt}`);
         const initialisedSession = await this.cache.get(this.JWTKey(jwt));
         request.logger.info(`[ACTIVATE-SESSION] session details ${initialisedSession}`);
@@ -67,14 +85,12 @@ export class AdapterCacheService extends CacheService {
         const userSessionKey = {segment: partition, id: `${request.yar.id}:${payload.group}`};
         request.logger.info(`[ACTIVATE-SESSION] session metadata ${userSessionKey}`);
         const {redirectPath} = await super.activateSession(jwt, request);
-
         let redirectPathNew = redirectPath
         const form_session_identifier = initialisedSession.metadata?.form_session_identifier;
         if (form_session_identifier) {
             userSessionKey.id = `${userSessionKey.id}:${form_session_identifier}`;
             redirectPathNew = `${redirectPathNew}?form_session_identifier=${form_session_identifier}`;
         }
-
         if (config.overwriteInitialisedSession) {
             request.logger.info("[ACTIVATE-SESSION] Replacing user session with initialisedSession");
             this.cache.set(userSessionKey, initialisedSession, sessionTimeout);
@@ -104,7 +120,7 @@ export class AdapterCacheService extends CacheService {
      * @param additionalIdentifier - appended to the id
      */
     //@ts-ignore
-    Key(request: HapiRequest, additionalIdentifier?: ADDITIONAL_IDENTIFIER) {
+    Key(request: HapiRequest, additionalIdentifier?: ADDITIONAL_IDENTIFIER): { segment: string; id: string } {
         let id = `${request.yar.id}:${request.params.id}`;
 
         if (request.query.form_session_identifier) {
@@ -125,94 +141,44 @@ export class AdapterCacheService extends CacheService {
      * @param configuration form definition configurations
      * @param server server object
      */
-    async setFormConfiguration(formId: string, configuration: any, server: HapiServer) {
-        if (formId && configuration) {
-            //@ts-ignore
-            if (server.app.redis) {
-                await this.addConfigurationsToRedisCache(server, configuration, formId);
-            } else {
-                await this.addConfigurationIntoInMemoryCache(configuration, formId, server);
-            }
-        }
-    }
-
-    private async addConfigurationIntoInMemoryCache(configuration: any, formId: string, server: HapiServer) {
-        const hashValue = Crypto.createHash('sha256').update(JSON.stringify(configuration)).digest('hex')
+    async setFormConfiguration(formId: string, configuration: any): Promise<void> {
+        if (!formId || !configuration) return;
+        const hashValue = Crypto.createHash('sha256')
+            .update(JSON.stringify(configuration))
+            .digest('hex');
+        const key = `${FORMS_KEY_PREFIX}${formId}`;
         try {
-            const jsonDataString = await this.cache.get(`${FORMS_KEY_PREFIX}${formId}`);
-            if (jsonDataString === null) {
-                // Adding new config into redis cache service with the hash value
+            const existingConfigString = await this.formStorage.get(key);
+            if (existingConfigString === null) {
+                // Adding new config with the hash value
                 const stringConfig = JSON.stringify({
                     ...configuration,
                     id: configuration.id,
                     hash: hashValue
                 });
-                //@ts-ignore
-                server.app.inMemoryFormKeys.push(`${FORMS_KEY_PREFIX}${formId}`)
-                // Adding data into redis cache
-                await this.cache.set(`${FORMS_KEY_PREFIX}${formId}`, stringConfig, {expiresIn: 0});
+                await this.formStorage.set(key, stringConfig);
             } else {
-                // Redis has the data and gets current data set to check hash
-                const configObj = JSON.parse(jsonDataString);
-                if (configObj && configObj.hash && hashValue !== configObj.hash) {
-                    // if hash function is change then updating the configuration
+                // Check if hash has changed
+                const existingConfig = JSON.parse(existingConfigString);
+                if (existingConfig?.hash !== hashValue) {
+                    // Hash has changed, update the configuration
                     const stringConfig = JSON.stringify({
                         ...configuration,
                         id: configuration.id,
                         hash: hashValue
                     });
-                    await this.cache.set(`${FORMS_KEY_PREFIX}${formId}`, stringConfig, {expiresIn: 0});
+                    await this.formStorage.set(key, stringConfig);
                 }
             }
         } catch (error) {
             console.log(error);
         }
     }
 
-    private async addConfigurationsToRedisCache(server: HapiServer, configuration: any, formId: string) {
-        //@ts-ignore
-        const redisClient: Redis = server.app.redis
-        const hashValue = Crypto.createHash('sha256').update(JSON.stringify(configuration)).digest('hex')
-        if (redisClient) {
-            const jsonDataString = await redisClient.get(`${FORMS_KEY_PREFIX}${formId}`);
-            if (jsonDataString === null) {
-                // Adding new config into redis cache service with the hash value
-                const stringConfig = JSON.stringify({
-                    ...configuration,
-                    id: configuration.id,
-                    hash: hashValue
-                });
-                // Adding data into redis cache
-                await redisClient.set(`${FORMS_KEY_PREFIX}${formId}`, stringConfig);
-            } else {
-                // Redis has the data and gets current data set to check hash
-                const configObj = JSON.parse(jsonDataString);
-                if (configObj && configObj.hash && hashValue !== configObj.hash) {
-                    // if hash function is change then updating the configuration
-                    const stringConfig = JSON.stringify({
-                        ...configuration,
-                        id: configuration.id,
-                        hash: hashValue
-                    });
-                    await redisClient.set(`${FORMS_KEY_PREFIX}${formId}`, stringConfig);
-                }
-            }
-        }
-    }
-
-    async getFormAdapterModel(formId: string, request: HapiRequest) {
-        //@ts-ignore
-        if (request.server.app.redis) {
-            return await this.getConfigurationFromRedisCache(request, formId);
-        } else {
-            return await this.getConfigurationFromInMemoryCache(request, formId);
-        }
-    }
-
-    private async getConfigurationFromInMemoryCache(request: HapiRequest, formId: string) {
+    async getFormAdapterModel(formId: string, request: HapiRequest): Promise<AdapterFormModel> {
         const {translationLoaderService} = request.services([]);
         const translations = translationLoaderService.getTranslations();
-        const jsonDataString = await this.cache.get(`${FORMS_KEY_PREFIX}${formId}`);
+        const jsonDataString = await this.formStorage.get(`${FORMS_KEY_PREFIX}${formId}`);
         if (jsonDataString !== null) {
             const configObj = JSON.parse(jsonDataString);
             return new AdapterFormModel(configObj.configuration, {
@@ -221,7 +187,7 @@ export class AdapterCacheService extends CacheService {
                 previewMode: true,
                 translationEn: translations.en,
                 translationCy: translations.cy
-            })
+            });
         }
         request.logger.error({
             ...LOGGER_DATA,
@@ -230,72 +196,16 @@ export class AdapterCacheService extends CacheService {
         throw Boom.notFound("Cannot find the given form");
     }
 
-    private async getConfigurationFromRedisCache(request: HapiRequest, formId: string) {
-        //@ts-ignore
-        const redisClient: Redis = request.server.app.redis
-        const {translationLoaderService} = request.services([]);
-        const translations = translationLoaderService.getTranslations();
-        const jsonDataString = await redisClient.get(`${FORMS_KEY_PREFIX}${formId}`);
-        if (jsonDataString !== null) {
-            const configObj = JSON.parse(jsonDataString);
-            return new AdapterFormModel(configObj.configuration, {
-                basePath: configObj.id ? configObj.id : formId,
-                hash: configObj.hash,
-                previewMode: true,
-                translationEn: translations.en,
-                translationCy: translations.cy
-            })
-        }
-        request.logger.error({
-            ...LOGGER_DATA,
-            message: `[FORM-CACHE] Cannot find the form ${formId}`
-        });
-        throw Boom.notFound("Cannot find the given form");
-    }
-
-    private getRedisClient() {
-        if (redisHost || redisUri) {
-            const redisOptions: {
-                password?: string;
-                tls?: {};
-            } = {};
-
-            if (redisPassword) {
-                redisOptions.password = redisPassword;
-            }
-
-            if (redisTls) {
-                redisOptions.tls = {};
-            }
-
-            const client = isSingleRedis
-                ? new Redis(
-                    redisUri ?? {
-                        host: redisHost,
-                        port: redisPort,
-                        password: redisPassword,
-                    }
-                )
-                : new Redis.Cluster(
-                    [
-                        {
-                            host: redisHost,
-                            port: redisPort,
-                        },
-                    ],
-                    {
-                        dnsLookup: (address, callback) => callback(null, address, 4),
-                        redisOptions,
-                    }
-                );
-            return client;
-        } else {
-            console.log({
-                ...LOGGER_DATA,
-                message: `[FORM-CACHE] using memory caching`,
-            })
-        }
-    }
+    private getRedisClient(): Redis | null {
+       const client = createRedisClient();
+       if (!client) {
+           console.log({
+               ...LOGGER_DATA,
+               message: `[FORM-CACHE] using memory caching`,
+           });
+       }
+       return client;
+   }
 }
 
 export const catboxProvider = () => {
@@ -305,49 +215,16 @@ export const catboxProvider = () => {
      */
     const provider = {
         constructor: redisHost || redisUri ? CatboxRedis.Engine : CatboxMemory.Engine,
-        options: {},
+        options: {partition},
     };
 
     if (redisHost || redisUri) {
-        console.log("Starting redis session management")
-        const redisOptions: {
-            password?: string;
-            tls?: {};
-        } = {};
-
-        if (redisPassword) {
-            redisOptions.password = redisPassword;
-        }
-
-        if (redisTls) {
-            redisOptions.tls = {};
-        }
-
-        const client = isSingleRedis
-            ? new Redis(
-                redisUri ?? {
-                    host: redisHost,
-                    port: redisPort,
-                    password: redisPassword,
-                }
-            )
-            : new Redis.Cluster(
-                [
-                    {
-                        host: redisHost,
-                        port: redisPort,
-                    },
-                ],
-                {
-                    dnsLookup: (address, callback) => callback(null, address, 4),
-                    redisOptions,
-                }
-            );
-        provider.options = {client, partition};
-        console.log(`Redis Url : ${redisUri} session management`);
+       console.log("Starting redis session management");
+       const client = createRedisClient();
+       provider.options = {client, partition};
+       console.log(`Redis Url : ${redisUri} session management`);
     } else {
-        console.log("Starting in memory session management")
-        provider.options = {partition};
+        console.log("Starting in memory session management");
     }
 
     return provider;
