asksuite-core/services/GlobalCacheManager.js

const { CacheRedis } = require('../util/CacheRedis');
const AsksuiteProcessingNaturalUtils = require('../AsksuiteProcessingNaturalUtils');
const StringUtils = require('../util/StringUtils');

class GlobalCacheManager {
  constructor(redisConfig, defaultTTL) {
    /** @private */
    this._DEFAULT_PREFIX = 'global';

    /** @private */
    this._DEFAULT_TTL = defaultTTL || 86400; // default 1 day

    /** @private */
    this._redisClient = this._getCacheConfig(redisConfig);

    /** @private */
    this._layersCache = {};

    /** @private */
    this._utils = new AsksuiteProcessingNaturalUtils();
  }

  /**
   * @typedef {Object} LayerConfig
   * @property {string} name - The name of the layer.
   * @property {number} ttl - Time to live (TTL) for the layer.
   * @param {LayerConfig[]} layers - An array of LayerConfig objects.
   */
  addLayers(layers) {
    this._layersCache = layers.reduce((acc, item) => {
      acc[item.name] = item;
      return acc;
    }, this._layersCache);
  }

  /**
   * @param {string} layer
   * @param {*} request
   * @param {*} intent
   */
  async set(layer, request, intent) {
    const text = request.text;
    const key = this._generateCacheKey(layer, request.language, request.languages, text);

    const processingStep =
      intent.processingStep ||
      (intent.processingSteps && intent.processingSteps.find((p) => p.resolver === layer)[0]);

    const value = {
      text,
      processingStep,
      resolver: layer,
      intent: intent.intent,
      extractedData: intent.extractedData,
      fromCache: true,
    };

    await this._redisClient.set(key, value, this._layersCache[layer].ttl);
  }

  /**
   * @param {string} layer
   * @param {*} request
   */
  async get(layer, request) {
    const key = this._generateCacheKey(layer, request.language, request.languages, request.text);
    let value = await this._redisClient.get(key);

    if (!value) {
      return null;
    }

    value = this._utils.findDialogByIntent(request, value.intent);
    return value;
  }

  /**
   * @param {string} layerName
   * @returns {boolean} boolean
   */
  isGlobalLayer(layerName) {
    return layerName in this._layersCache;
  }

  /**
   * @private
   * @param {*} redis
   * @param {string} prefix
   * @param {number} ttl
   */
  _getCacheConfig(redis) {
    if (!redis) {
      return null;
    }

    return new CacheRedis({
      client: redis,
      prefixKey: this._DEFAULT_PREFIX,
      expirationTime: this._DEFAULT_TTL,
      isJson: true,
    });
  }

  /**
   * @private
   * @param {string} layer
   * @param {string} language
   * @param {string[]} languages
   * @param {string} text
   */
  _generateCacheKey(layer, language, languages, text) {
    const resolvedLanguage = this._utils.resolveLanguage(language, languages);

    const normalizedText = StringUtils.normalizeText(text);
    const textHash = StringUtils.generateHash(normalizedText);
    return `${layer.toLowerCase()}:${resolvedLanguage}:${textHash}`;
  }
}

module.exports = GlobalCacheManager;