node redis 4.0.4+

example.js

// ATTEMPT GET FROM CACHE
if (config.cacheenabled) {
  redisInstance = new RedisService();
  await redisInstance.connect();

  const values = await redisInstance.getValues(name, request.query);

  if (values) {
      log.info(`[REDIS]: getting inventories from cache`);
      await redisInstance.quit();
      response.json(values);
      return;
  }
}
  
// MAIN REQUEST

if (config.cacheenabled && redisInstance) {
  const hash = redisInstance.createHash({
    url: name,
    payload: request.query,
  });

  log.info(`[REDIS]: setting inventories to cache`);
  await redisInstance.set(hash, cacheInSeconds, inventories);
  await redisInstance.quit();
}

RedisService.ts

import hash from 'object-hash';
import { createClient } from 'redis';
import { config } from '../config';
import { serialize } from '../utils/objectTransformer';
import { log } from '../utils/errors';

export const REDIS_KEY_PREFIX = `PROJECTPREFIX-${config.env?.toLowerCase()}`;

class RedisService {
  client: any;

  connect = async () => {
    this.client = createClient({
      url: config.redisconnectionstring,
    });

    this.client.on('error', (error: any) => {
      log.error(`Failed to connect to redis ${error}`);
    });

    await this.client.connect();

    return this.client;
  };

  quit = async () => {
    this.client.quit();
  };

  createHash = ({
    url,
    payload,
    options,
  }: {
    url: string;
    payload: any;
    options?: { query?: any };
  }) => {
    return options?.query
      ? `${REDIS_KEY_PREFIX}-${url}?${serialize(options.query)}-${hash(
          payload
        )}`
      : `${REDIS_KEY_PREFIX}-${url}-${hash(payload)}`;
  };

  get = async ({
    url,
    payload,
    options,
  }: {
    url: string;
    payload: any;
    options?: any;
  }) => {
    const hashedValue = this.createHash({ url, payload, options });
    const cacheValue = await this.client.get(hashedValue);

    if (typeof cacheValue === 'string') {
      return JSON.parse(cacheValue);
    }
    return undefined;
  };

  set = (entityHash: string, cacheInSeconds: number, data: any) => {
    return this.client.set(entityHash, JSON.stringify(data), {
      EX: cacheInSeconds,
      NX: true,
    });
  };

  getValues = async (name: string, payload: any) => {
    const cachedValues = await this.get({ url: name, payload });
    if (!cachedValues) return null;

    if (config.isDev) {
      log.info(`[REDIS]: getting ${name} from cache`);
    }

    return cachedValues;
  };
}

export { RedisService };