descript-redis-cache 3.0.0

package/.editorconfig

@@ -0,0 +1,19 @@
+# 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

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

package/.eslintrc.js

@@ -0,0 +1,23 @@
+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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Boris Zhidkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# descript-redis-cache
+Plugin to use Redis as a cache for responses in Descript
+
+## Usage
+
+```js
+const de = require('descript');
+const deRedisCache = require('descript-redis-cache');
+
+const context = new de.Context(req, res, {
+    cache: new deMemcached(myCacheConfig, logger)
+});
+```
+
+## Config
+
+```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
+}
+```
+
+## Logger
+
+Optionally you can pass logger object in the constructor. It should implement standard `Console` methods.

package/index.js

@@ -0,0 +1,280 @@
+'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;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "descript-redis-cache",
+  "version": "3.0.0",
+  "description": "plugin for descript to use redis as cache",
+  "main": "index.js",
+  "scripts": {
+    "test": "eslint ."
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "keywords": [
+    "descript",
+    "redis"
+  ],
+  "author": "Boris Zhidkov <eljusto@yandex-team.ru>",
+  "license": "MIT",
+  "bugs": {
+    "url": ""
+  },
+  "homepage": "",
+  "engines": {
+    "node": ">= 10.0.0"
+  },
+  "dependencies": {
+    "contimer": "^1.0.0",
+    "ioredis": "^4.28.2"
+  },
+  "peerDependencies": {
+    "descript": ">=3"
+  },
+  "devDependencies": {
+    "eslint": "^7.1.0"
+  }
+}