descript-redis-cache 3.0.0 → 4.0.1

package/README.md

@@ -1,28 +1,46 @@
 # descript-redis-cache
-Plugin to use Redis as a cache for responses in Descript
+Plugin to use Redis as a cache in Descript
 
 ## Usage
 
 ```js
-const de = require('descript');
-const deRedisCache = require('descript-redis-cache');
+import de from 'descript';
+import deRedisCache from 'descript-redis-cache';
 
-const context = new de.Context(req, res, {
-    cache: new deMemcached(myCacheConfig, logger)
+const redisCache = new deRedisCache(options);
+
+const myBlock = de.http({
+    block: { /* ... */ },
+    options: {
+        key: ({ params }) => '_some_cache_key_from_params_',
+        cache: deRedisCache,
+    }
 });
 ```
 
-## Config
+## Options
 
-```js
-{
-    defaultKeyTTL: 60 * 60 * 24, // key ttl in seconds
-    generation: 1, // increment generation to invalidate all key across breaking changes releases
-    readTimeout: 100, // read timeout in milliseconds,
-    redisOptions: {}, // @see https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
+```ts
+import type { ClusterNode, ClusterOptions, RedisOptions } from 'ioredis';
+
+export interface Options {
+    // key TTL in seconds (default: 60 * 60 * 24)
+    defaultKeyTTL?: number;
+    // increment generation to invalidate all key across breaking changes releases (default: 1)
+    generation?: number;
+    // read timeout in milliseconds (default: 100)
+    readTimeout?: number;
+    redis: (
+        { startupNodes: ClusterNode[], options?: ClusterOptions } |
+        { options: RedisOptions }
+    );
 }
 ```
 
 ## Logger
 
 Optionally you can pass logger object in the constructor. It should implement standard `Console` methods.
+
+```js
+const redisCache = new deRedisCache(options, logger);
+```

package/build/index.js

@@ -0,0 +1,242 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Cache_instances, _Cache_client, _Cache_logger, _Cache_options, _Cache_normalizeKey, _Cache_log;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const node_crypto_1 = require("node:crypto");
+const descript_1 = __importDefault(require("descript"));
+const ioredis_1 = require("ioredis");
+class Cache {
+    constructor(options, logger) {
+        _Cache_instances.add(this);
+        _Cache_client.set(this, void 0);
+        _Cache_logger.set(this, void 0);
+        _Cache_options.set(this, void 0);
+        __classPrivateFieldSet(this, _Cache_options, {
+            defaultKeyTTL: 60 * 60 * 24,
+            generation: 1,
+            readTimeout: 100,
+            ...options,
+        }, "f");
+        __classPrivateFieldSet(this, _Cache_logger, logger, "f");
+        if ('startupNodes' in __classPrivateFieldGet(this, _Cache_options, "f").redis) {
+            __classPrivateFieldSet(this, _Cache_client, new ioredis_1.Cluster(__classPrivateFieldGet(this, _Cache_options, "f").redis.startupNodes, __classPrivateFieldGet(this, _Cache_options, "f").redis.options), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Cache_client, new ioredis_1.Redis(__classPrivateFieldGet(this, _Cache_options, "f").redis.options), "f");
+        }
+        __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+            type: "REDIS_CACHE_INITIALIZED" /* EVENT.REDIS_CACHE_INITIALIZED */,
+            options: { ...__classPrivateFieldGet(this, _Cache_options, "f") },
+        });
+    }
+    get({ key }) {
+        const normalizedKey = __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_normalizeKey).call(this, key);
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                type: "REDIS_CACHE_READ_START" /* EVENT.REDIS_CACHE_READ_START */,
+                key,
+                normalizedKey,
+            });
+            const networkTimerStart = process.hrtime();
+            const totalTimerStart = process.hrtime();
+            let isTimeout = false;
+            const timer = setTimeout(() => {
+                isTimeout = true;
+                const networkTimer = process.hrtime(networkTimerStart);
+                const totalTimer = process.hrtime(totalTimerStart);
+                __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                    type: "REDIS_CACHE_READ_TIMEOUT" /* EVENT.REDIS_CACHE_READ_TIMEOUT */,
+                    key,
+                    normalizedKey,
+                    timers: {
+                        network: networkTimer,
+                        total: totalTimer,
+                    },
+                });
+                reject(descript_1.default.error({
+                    id: "REDIS_CACHE_READ_TIMEOUT" /* EVENT.REDIS_CACHE_READ_TIMEOUT */,
+                }));
+            }, __classPrivateFieldGet(this, _Cache_options, "f").readTimeout);
+            __classPrivateFieldGet(this, _Cache_client, "f").get(normalizedKey, (error, data) => {
+                if (isTimeout) {
+                    return;
+                }
+                const networkTimer = process.hrtime(networkTimerStart);
+                clearTimeout(timer);
+                if (error) {
+                    const totalTimer = process.hrtime(totalTimerStart);
+                    __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                        type: "REDIS_CACHE_READ_ERROR" /* EVENT.REDIS_CACHE_READ_ERROR */,
+                        error,
+                        key,
+                        normalizedKey,
+                        timers: {
+                            network: networkTimer,
+                            total: totalTimer,
+                        },
+                    });
+                    reject(descript_1.default.error({
+                        id: "REDIS_CACHE_READ_ERROR" /* EVENT.REDIS_CACHE_READ_ERROR */,
+                    }));
+                }
+                else if (!data) {
+                    const totalTimer = process.hrtime(totalTimerStart);
+                    __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                        type: "REDIS_CACHE_READ_KEY_NOT_FOUND" /* EVENT.REDIS_CACHE_READ_KEY_NOT_FOUND */,
+                        key,
+                        normalizedKey,
+                        timers: {
+                            network: networkTimer,
+                            total: totalTimer,
+                        },
+                    });
+                    reject(descript_1.default.error({
+                        id: "REDIS_CACHE_READ_KEY_NOT_FOUND" /* EVENT.REDIS_CACHE_READ_KEY_NOT_FOUND */,
+                    }));
+                }
+                else {
+                    let parsedValue;
+                    try {
+                        parsedValue = JSON.parse(data);
+                    }
+                    catch (error) {
+                        const totalTimer = process.hrtime(totalTimerStart);
+                        __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                            type: "REDIS_CACHE_JSON_PARSING_FAILED" /* EVENT.REDIS_CACHE_JSON_PARSING_FAILED */,
+                            data,
+                            error,
+                            key,
+                            normalizedKey,
+                            timers: {
+                                network: networkTimer,
+                                total: totalTimer,
+                            },
+                        });
+                        reject(descript_1.default.error({
+                            id: "REDIS_CACHE_JSON_PARSING_FAILED" /* EVENT.REDIS_CACHE_JSON_PARSING_FAILED */,
+                        }));
+                        return;
+                    }
+                    const totalTimer = process.hrtime(totalTimerStart);
+                    __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                        type: "REDIS_CACHE_READ_DONE" /* EVENT.REDIS_CACHE_READ_DONE */,
+                        data,
+                        key,
+                        normalizedKey,
+                        timers: {
+                            network: networkTimer,
+                            total: totalTimer,
+                        },
+                    });
+                    resolve(parsedValue);
+                }
+            });
+        });
+    }
+    set({ key, value, maxage = __classPrivateFieldGet(this, _Cache_options, "f").defaultKeyTTL }) {
+        if (typeof value === 'undefined') {
+            return Promise.resolve();
+        }
+        const totalTimerStart = process.hrtime();
+        const normalizedKey = __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_normalizeKey).call(this, key);
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                type: "REDIS_CACHE_WRITE_START" /* EVENT.REDIS_CACHE_WRITE_START */,
+                key,
+                normalizedKey,
+            });
+            let json;
+            try {
+                json = JSON.stringify(value);
+            }
+            catch (error) {
+                const totalTimer = process.hrtime(totalTimerStart);
+                __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                    type: "REDIS_CACHE_JSON_STRINGIFY_FAILED" /* EVENT.REDIS_CACHE_JSON_STRINGIFY_FAILED */,
+                    data: value,
+                    error,
+                    key,
+                    normalizedKey,
+                    timers: {
+                        total: totalTimer,
+                    },
+                });
+                reject(descript_1.default.error({
+                    id: "REDIS_CACHE_JSON_STRINGIFY_FAILED" /* EVENT.REDIS_CACHE_JSON_STRINGIFY_FAILED */,
+                }));
+                return;
+            }
+            const networkTimerStart = process.hrtime();
+            // maxage - seconds
+            __classPrivateFieldGet(this, _Cache_client, "f").set(normalizedKey, json, 'EX', maxage, (error, done) => {
+                const networkTimer = process.hrtime(networkTimerStart);
+                const totalTimer = process.hrtime(totalTimerStart);
+                if (error) {
+                    __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                        type: "REDIS_CACHE_WRITE_ERROR" /* EVENT.REDIS_CACHE_WRITE_ERROR */,
+                        error,
+                        key,
+                        normalizedKey,
+                        timers: {
+                            network: networkTimer,
+                            total: totalTimer,
+                        },
+                    });
+                    reject(descript_1.default.error({
+                        id: "REDIS_CACHE_WRITE_ERROR" /* EVENT.REDIS_CACHE_WRITE_ERROR */,
+                    }));
+                }
+                else if (!done) {
+                    __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                        type: "REDIS_CACHE_WRITE_FAILED" /* EVENT.REDIS_CACHE_WRITE_FAILED */,
+                        key,
+                        normalizedKey,
+                        timers: {
+                            network: networkTimer,
+                            total: totalTimer,
+                        },
+                    });
+                    reject(descript_1.default.error({
+                        id: "REDIS_CACHE_WRITE_FAILED" /* EVENT.REDIS_CACHE_WRITE_FAILED */,
+                    }));
+                }
+                else {
+                    __classPrivateFieldGet(this, _Cache_instances, "m", _Cache_log).call(this, {
+                        type: "REDIS_CACHE_WRITE_DONE" /* EVENT.REDIS_CACHE_WRITE_DONE */,
+                        data: json,
+                        key,
+                        normalizedKey,
+                        timers: {
+                            network: networkTimer,
+                            total: totalTimer,
+                        },
+                    });
+                    resolve();
+                }
+            });
+        });
+    }
+}
+exports.Cache = Cache;
+_Cache_client = new WeakMap(), _Cache_logger = new WeakMap(), _Cache_options = new WeakMap(), _Cache_instances = new WeakSet(), _Cache_normalizeKey = function _Cache_normalizeKey(key) {
+    const value = `g${__classPrivateFieldGet(this, _Cache_options, "f").generation}:${key}`;
+    return (0, node_crypto_1.hash)('sha512', value);
+}, _Cache_log = function _Cache_log(event) {
+    if (__classPrivateFieldGet(this, _Cache_logger, "f")) {
+        __classPrivateFieldGet(this, _Cache_logger, "f").log(event);
+    }
+};

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "descript-redis-cache",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "plugin for descript to use redis as cache",
-  "main": "index.js",
+  "main": "./build/index.js",
   "scripts": {
-    "test": "eslint ."
+    "eslint": "npx eslint .",
+    "test": "npx vitest",
+    "ts-compile": "npx tsc --noEmit",
+    "prepack": "rm -rf build && npx tsc -p ./tsconfig-build.json"
   },
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "https://github.com/descript-org/descript-redis-cache"
   },
   "keywords": [
     "descript",
@@ -21,16 +24,26 @@
   },
   "homepage": "",
   "engines": {
-    "node": ">= 10.0.0"
+    "node": ">= 20.12.0"
   },
+  "files": [
+    "build"
+  ],
   "dependencies": {
-    "contimer": "^1.0.0",
-    "ioredis": "^4.28.2"
+    "ioredis": "^5.4.1"
   },
   "peerDependencies": {
-    "descript": ">=3"
+    "descript": ">=4"
   },
   "devDependencies": {
-    "eslint": "^7.1.0"
+    "@eslint/js": "^9.14.0",
+    "@stylistic/eslint-plugin-ts": "^2.11.0",
+    "@types/eslint__js": "^8.42.3",
+    "@types/node": "^22.9.0",
+    "descript": "^4.0.5",
+    "eslint": "^9.15.0",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.15.0",
+    "vitest": "^2.1.5"
   }
 }

package/.editorconfig

@@ -1,19 +0,0 @@
-# top-most EditorConfig file
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-indent_style = space
-indent_size = 4
-
-# Data files
-[*.{json, yml}]
-indent_size = 2
-
-# Makefiles
-[*{M,m}akefile]
-indent_style = tab

package/.eslintignore

@@ -1,3 +0,0 @@
-.git/
-.npm/
-node_modules/

package/.eslintrc.js

@@ -1,23 +0,0 @@
-module.exports = {
-    'env': {
-        'es6': true,
-        'node': true,
-    },
-    'extends': [
-        'eslint:recommended',
-    ],
-    'rules': {
-        'array-bracket-spacing': [ 'error', 'always' ],
-        'comma-dangle': [ 'error', 'always-multiline' ],
-        'eol-last': 'error',
-        'indent': [ 'error', 4 ],
-        'linebreak-style': [ 'error', 'unix' ],
-        'no-empty': [ 'error', { 'allowEmptyCatch': true } ],
-        'no-multiple-empty-lines': [ 'error', { 'max': 1, 'maxBOF': 0 } ],
-        'no-var': [ 'error' ],
-        'object-curly-spacing': [ 'error', 'always' ],
-        'quotes': [ 'error', 'single' ],
-        'semi': [ 'error', 'always' ],
-        'space-infix-ops': 'error',
-    },
-};

package/index.js

@@ -1,280 +0,0 @@
-'use strict';
-
-const contimer = require('contimer');
-const crypto = require('crypto');
-const de = require('descript');
-const Redis = require('ioredis');
-
-class DescriptRedisCache {
-
-    constructor(options, logger) {
-        this._options = Object.assign({
-            defaultKeyTTL: 60 * 60 * 24, // key ttl in seconds
-            generation: 1, // increment generation to invalidate all key across breaking changes releases
-            readTimeout: 100, // read timeout in milliseconds,
-            redisOptions: {},
-        }, options);
-
-        this._logger = logger;
-
-        this._client = new Redis(options.redisOptions);
-
-        this._log({
-            type: DescriptRedisCache.EVENT.REDIS_CACHE_INITIALIZED,
-            options: options,
-        });
-    }
-
-    getClient() {
-        return this._client;
-    }
-
-    get({ key, context }) {
-        const normalizedKey = this.normalizeKey(key);
-
-        return new Promise((resolve, reject) => {
-            this._log({
-                type: DescriptRedisCache.EVENT.REDIS_CACHE_READ_START,
-                key,
-                normalizedKey,
-            }, context);
-
-            const networkTimerStop = contimer.start({}, 'descript-redis-cache.get.network');
-            const totalTimerStop = contimer.start({}, 'descript-redis-cache.get.total');
-
-            let isTimeout = false;
-
-            const timer = setTimeout(() => {
-                isTimeout = true;
-
-                const networkTimer = networkTimerStop();
-                const totalTimer = totalTimerStop();
-
-                this._log({
-                    type: DescriptRedisCache.EVENT.REDIS_CACHE_READ_TIMEOUT,
-                    key,
-                    normalizedKey,
-                    timers: {
-                        network: networkTimer,
-                        total: totalTimer,
-                    },
-                }, context);
-
-                reject(de.error({
-                    id: DescriptRedisCache.EVENT.REDIS_CACHE_READ_TIMEOUT,
-                }));
-            }, this._options.readTimeout);
-
-            this._client.get(normalizedKey, (error, data) => {
-                if (isTimeout) {
-                    return;
-                }
-
-                const networkTimer = networkTimerStop();
-                clearTimeout(timer);
-
-                if (error) {
-                    const totalTimer = totalTimerStop();
-                    this._log({
-                        type: DescriptRedisCache.EVENT.REDIS_CACHE_READ_ERROR,
-                        error,
-                        key,
-                        normalizedKey,
-                        timers: {
-                            network: networkTimer,
-                            total: totalTimer,
-                        },
-                    }, context);
-
-                    reject(de.error({
-                        id: DescriptRedisCache.EVENT.REDIS_CACHE_READ_ERROR,
-                    }));
-                } else if (!data) {
-                    const totalTimer = totalTimerStop();
-                    this._log({
-                        type: DescriptRedisCache.EVENT.REDIS_CACHE_READ_KEY_NOT_FOUND,
-                        key,
-                        normalizedKey,
-                        timers: {
-                            network: networkTimer,
-                            total: totalTimer,
-                        },
-                    }, context);
-
-                    reject(de.error({
-                        id: DescriptRedisCache.EVENT.REDIS_CACHE_READ_KEY_NOT_FOUND,
-                    }));
-                } else {
-                    let parsedValue;
-                    try {
-                        parsedValue = JSON.parse(data);
-                    } catch (error) {
-                        const totalTimer = totalTimerStop();
-                        this._log({
-                            type: DescriptRedisCache.EVENT.REDIS_CACHE_JSON_PARSING_FAILED,
-                            data,
-                            error,
-                            key,
-                            normalizedKey,
-                            timers: {
-                                network: networkTimer,
-                                total: totalTimer,
-                            },
-                        }, context);
-
-                        reject(de.error({
-                            id: DescriptRedisCache.EVENT.REDIS_CACHE_JSON_PARSING_FAILED,
-                        }));
-                        return;
-                    }
-
-                    const totalTimer = totalTimerStop();
-                    this._log({
-                        type: DescriptRedisCache.EVENT.REDIS_CACHE_READ_DONE,
-                        data,
-                        key,
-                        normalizedKey,
-                        timers: {
-                            network: networkTimer,
-                            total: totalTimer,
-                        },
-                    }, context);
-
-                    resolve(parsedValue);
-                }
-            });
-        });
-    }
-
-    set({ key, value, maxage = this._options.defaultKeyTTL, context } ) {
-        if (typeof value === 'undefined') {
-            return;
-        }
-
-        const totalTimerStop = contimer.start({}, 'descript-redis-cache.set.total');
-        const normalizedKey = this.normalizeKey(key);
-
-        return new Promise((resolve, reject) => {
-            this._log({
-                type: DescriptRedisCache.EVENT.REDIS_CACHE_WRITE_START,
-                key,
-                normalizedKey,
-            }, context);
-
-            // save to cache only serializable data
-            const safeSerializableValue = {
-                status_code: value.status_code,
-                headers: value.headers,
-                result: value.result,
-            };
-
-            let json;
-            try {
-                json = JSON.stringify(safeSerializableValue);
-            } catch (error) {
-                const totalTimer = totalTimerStop();
-                this._log({
-                    type: DescriptRedisCache.EVENT.REDIS_CACHE_JSON_STRINGIFY_FAILED,
-                    data: value,
-                    error,
-                    key,
-                    normalizedKey,
-                    timers: {
-                        network: {},
-                        total: totalTimer,
-                    },
-                }, context);
-                reject(de.error({
-                    id: DescriptRedisCache.EVENT.REDIS_CACHE_JSON_STRINGIFY_FAILED,
-                }));
-                return;
-            }
-
-            const networkTimerStop = contimer.start({}, 'descript-redis-cache.set.network');
-            // maxage - seconds
-            this._client.set(normalizedKey, json, 'EX', maxage, (error, done) => {
-                const networkTimer = networkTimerStop();
-                const totalTimer = totalTimerStop();
-                if (error) {
-                    this._log({
-                        type: DescriptRedisCache.EVENT.REDIS_CACHE_WRITE_ERROR,
-                        error,
-                        key,
-                        normalizedKey,
-                        timers: {
-                            network: networkTimer,
-                            total: totalTimer,
-                        },
-                    }, context);
-                    reject(de.error({
-                        id: DescriptRedisCache.EVENT.REDIS_CACHE_WRITE_ERROR,
-                    }));
-                } else if (!done) {
-                    this._log({
-                        type: DescriptRedisCache.EVENT.REDIS_CACHE_WRITE_FAILED,
-                        key,
-                        normalizedKey,
-                        timers: {
-                            network: networkTimer,
-                            total: totalTimer,
-                        },
-                    }, context);
-                    reject(de.error({
-                        id: DescriptRedisCache.EVENT.REDIS_CACHE_WRITE_FAILED,
-                    }));
-                } else {
-                    this._log({
-                        type: DescriptRedisCache.EVENT.REDIS_CACHE_WRITE_DONE,
-                        data: json,
-                        key,
-                        normalizedKey,
-                        timers: {
-                            network: networkTimer,
-                            total: totalTimer,
-                        },
-                    }, context);
-                    resolve();
-                }
-            });
-        });
-    }
-
-    /**
-     * Generates normalized SHA-512 key with generation
-     * @param {string} key
-     * @returns {string}
-     */
-    normalizeKey(key) {
-        const value = `g${ this._options.generation }:${ key }`;
-        return crypto
-            .createHash('sha512')
-            .update(value, 'utf8')
-            .digest('hex');
-    }
-
-    _log(event, context) {
-        if (this._logger) {
-            this._logger.log(event, context);
-        }
-    }
-}
-
-DescriptRedisCache.EVENT = {
-    REDIS_CACHE_INITIALIZED: 'REDIS_CACHE_INITIALIZED',
-
-    REDIS_CACHE_JSON_PARSING_FAILED: 'REDIS_CACHE_JSON_PARSING_FAILED',
-    REDIS_CACHE_JSON_STRINGIFY_FAILED: 'REDIS_CACHE_JSON_STRINGIFY_FAILED',
-
-    REDIS_CACHE_READ_DONE: 'REDIS_CACHE_READ_DONE',
-    REDIS_CACHE_READ_ERROR: 'REDIS_CACHE_READ_ERROR',
-    REDIS_CACHE_READ_KEY_NOT_FOUND: 'REDIS_CACHE_READ_KEY_NOT_FOUND',
-    REDIS_CACHE_READ_START: 'REDIS_CACHE_READ_START',
-    REDIS_CACHE_READ_TIMEOUT: 'REDIS_CACHE_READ_TIMEOUT',
-
-    REDIS_CACHE_WRITE_DONE: 'REDIS_CACHE_WRITE_DONE',
-    REDIS_CACHE_WRITE_ERROR: 'REDIS_CACHE_WRITE_ERROR',
-    REDIS_CACHE_WRITE_FAILED: 'REDIS_CACHE_WRITE_FAILED',
-    REDIS_CACHE_WRITE_START: 'REDIS_CACHE_READ_START',
-};
-
-module.exports = DescriptRedisCache;