redis - updated to 2.8.2 (#965)

* Revert "removing packages that will not be affected by Keyv v4 to v5 migration (#945)"

This reverts commit 1164943.

* Update package.json

* redis - moving to 2.8.2

Author: jaredwray

packages/compress-brotli/README.md

@@ -0,0 +1,40 @@
+# @keyv/compress-brotli [<img width="100" align="right" src="https://jaredwray.com/images/keyv.svg" alt="keyv">](https://github.com/jaredwra/keyv)
+
+> Brotli compression for Keyv
+
+[![build](https://github.com/jaredwray/keyv/actions/workflows/tests.yaml/badge.svg)](https://github.com/jaredwray/keyv/actions/workflows/tests.yaml)
+[![codecov](https://codecov.io/gh/jaredwray/keyv/branch/main/graph/badge.svg?token=bRzR3RyOXZ)](https://codecov.io/gh/jaredwray/keyv)
+[![npm](https://img.shields.io/npm/v/@keyv/compress-brotli.svg)](https://www.npmjs.com/package/@keyv/compress-brotli)
+[![npm](https://img.shields.io/npm/dm/@keyv/compress-brotli)](https://npmjs.com/package/@keyv/compress-brotli)
+
+Brotli compression for [Keyv](https://github.com/jaredwray/keyv).
+
+Brotli is a data compression algorithm that is designed to be fast and efficient.
+
+## Install
+
+```shell
+npm install --save keyv @keyv/compress-brotli
+```
+
+## Usage
+
+```javascript
+const KeyvBrotli = require('@keyv/compress-brotli');
+const Keyv = require('keyv');
+
+const keyv = new Keyv({store: new Map(), compression: new KeyvBrotli()});
+
+```
+
+## API
+
+### @keyv/compress-brotli(\[options])
+
+#### options
+
+All options for @keyv/compress-brotli are based on the package [compress-brotli](https://github.com/Kikobeats/compress-brotli)
+
+## License
+
+MIT © Jared Wray

packages/compress-brotli/package.json

@@ -0,0 +1,83 @@
+{
+	"name": "@keyv/compress-brotli",
+	"version": "1.1.5",
+	"description": "brotli compression for keyv",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"build": "tsc --project tsconfig.dist.json",
+		"prepare": "yarn build",
+		"test": "xo && c8 ava --serial",
+		"test:ci": "xo && ava --serial",
+		"clean": "rm -rf node_modules && rm -rf ./coverage && rm -rf ./test/testdb.sqlite && rm -rf ./dist && rm -rf ./.nyc_output"
+	},
+	"xo": {
+		"rules": {
+			"unicorn/prefer-module": 0,
+			"@typescript-eslint/no-unsafe-call": 0,
+			"@typescript-eslint/consistent-type-definitions": 0,
+			"@typescript-eslint/no-unsafe-argument": 0,
+			"ava/no-ignored-test-files": [
+				"error",
+				{
+					"extensions": [
+						"js",
+						"ts"
+					]
+				}
+			],
+			"import/extensions": 0
+		}
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/jaredwray/keyv.git"
+	},
+	"keywords": [
+		"compress",
+		"brotli",
+		"keyv",
+		"storage",
+		"adapter",
+		"key",
+		"value",
+		"store",
+		"cache",
+		"ttl"
+	],
+	"author": "Jared Wray <me@jaredwray.com> (https://jaredwray.com)",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/jaredwray/keyv/issues"
+	},
+	"homepage": "https://github.com/jaredwray/keyv",
+	"dependencies": {
+		"compress-brotli": "^1.3.12"
+	},
+	"devDependencies": {
+		"@keyv/test-suite": "*",
+		"c8": "^8.0.1",
+		"json-buffer": "^3.0.1",
+		"keyv": "*",
+		"requirable": "^1.0.5",
+		"tsd": "^0.29.0",
+		"webpack": "^5.89.0"
+	},
+	"tsd": {
+		"directory": "test"
+	},
+	"engines": {
+		"node": ">= 12"
+	},
+	"files": [
+		"dist"
+	],
+	"ava": {
+		"extensions": [
+			"ts"
+		],
+		"require": [
+			"ts-node/register"
+		]
+	}
+}

packages/compress-brotli/src/index.ts

@@ -0,0 +1,36 @@
+import type {BrotliOptions, InputType} from 'node:zlib';
+import compressBrotli from 'compress-brotli';
+import type {Brotli, CompressResult, Options, SerializeResult, Serialize} from './types';
+
+class KeyvBrotli {
+	private readonly brotli: Brotli;
+	constructor(options?: Options) {
+		this.brotli = compressBrotli(options);
+	}
+
+	async compress(value: any, options?: BrotliOptions): CompressResult {
+		return this.brotli.compress(value, options);
+	}
+
+	async decompress<T>(data: InputType, options?: BrotliOptions): Promise<T> {
+		return await this.brotli.decompress(data, options) as T;
+	}
+
+	async serialize({value, expires}: Serialize): Promise<SerializeResult> {
+		const compressValue = await this.compress(value);
+		// @ts-expect-error - `expires` is not part of the `SerializeResult` type
+		return this.brotli.serialize({value: compressValue, expires});
+	}
+
+	async deserialize(data: CompressResult): Promise<Serialize> {
+		// eslint-disable-next-line @typescript-eslint/no-misused-promises
+		if (!data) {
+			return data;
+		}
+
+		const {value, expires} = this.brotli.deserialize(data) as Serialize;
+		return {value: await this.decompress(value), expires};
+	}
+}
+
+export = KeyvBrotli;

packages/compress-brotli/src/types.ts

@@ -0,0 +1,32 @@
+import type {BrotliOptions, CompressCallback, InputType} from 'node:zlib';
+import type {parse as JSONBparse, stringify as JSONBstringify} from 'json-buffer';
+
+export type CompressResult = Promise<Parameters<CompressCallback>[1]>;
+export type DecompressResult = Promise<ReturnType<typeof JSONBparse>>;
+
+export type SerializeResult = ReturnType<typeof JSONBstringify>;
+export type DeserializeResult = ReturnType<typeof JSONBparse>;
+
+type BrotliSerialize<T> = (source: InputType) => T;
+type BrotliDeserialize<T> = (source: CompressResult) => T;
+
+export type Serialize = {
+	value: InputType;
+	expires?: number;
+};
+
+export interface Options {
+	compressOptions?: BrotliOptions;
+	decompressOptions?: BrotliOptions;
+	enable?: boolean;
+	serialize?: any;
+	deserialize?: any;
+	iltorb?: any;
+}
+
+export interface Brotli {
+	serialize: BrotliSerialize<SerializeResult>;
+	deserialize: BrotliDeserialize<DeserializeResult>;
+	compress: (data: InputType, options?: BrotliOptions) => CompressResult;
+	decompress: (data: InputType, options?: BrotliOptions) => DecompressResult;
+}

packages/compress-brotli/test/test.ts

@@ -0,0 +1,125 @@
+import {constants as zlibConstants} from 'node:zlib';
+import v8 from 'node:v8';
+import test from 'ava';
+import json from 'json-buffer';
+import {keyvCompresstionTests} from '@keyv/test-suite';
+import KeyvBrotli from '../src/index';
+import type {DeserializeResult} from '../src/types';
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const {BROTLI_PARAM_MODE, BROTLI_PARAM_QUALITY} = zlibConstants;
+
+keyvCompresstionTests(test, new KeyvBrotli());
+
+test('object type compression/decompression', async t => {
+	const keyv = new KeyvBrotli();
+	const object = {
+		a: 1,
+		b: 'test',
+		c: true,
+	};
+	const compressed = await keyv.compress(object);
+	const decompressed = await keyv.decompress(compressed);
+	t.deepEqual(decompressed, object);
+});
+
+test('disable brotli compression', async t => {
+	const options = {
+		enable: false,
+	};
+	const keyv = new KeyvBrotli(options);
+	const compressed = await keyv.compress('whatever');
+	// @ts-expect-error Testing non-compressed value
+	t.is(compressed, 'whatever');
+	const decompressed: DeserializeResult = await keyv.decompress(compressed);
+	t.is(decompressed, 'whatever');
+});
+
+test('compression with compression options', async t => {
+	const options = {
+		compressOptions: {
+			chunkSize: 1024,
+			parameters: {
+				[BROTLI_PARAM_MODE]: 2,
+				[BROTLI_PARAM_QUALITY]: 7,
+			},
+		},
+	};
+
+	const keyv = new KeyvBrotli(options);
+	const keyvWithoutOptions = new KeyvBrotli();
+	const compressed = await keyv.compress('whatever');
+	const compressedWithoutOptions = await keyvWithoutOptions.compress('whatever');
+	t.not(compressed, compressedWithoutOptions);
+});
+
+test('decompression with decompression options', async t => {
+	const options = {
+		decompressOptions: {
+			chunkSize: 1024,
+			parameters: {
+				[BROTLI_PARAM_MODE]: 2,
+			},
+		},
+	};
+
+	const keyv = new KeyvBrotli(options);
+	const compressed = await keyv.compress('whatever');
+	const decompressed = await keyv.decompress(compressed);
+	t.is(decompressed, 'whatever');
+});
+
+test('compression/decompression with compression/decompression options', async t => {
+	const options = {
+		compressOptions: {
+			chunkSize: 1024,
+			parameters: {
+				[BROTLI_PARAM_MODE]: 2,
+			},
+		},
+		decompressOptions: {
+			chunkSize: 1024,
+			parameters: {
+				[BROTLI_PARAM_MODE]: 2,
+			},
+		},
+	};
+
+	const keyv = new KeyvBrotli(options);
+	const compressed = await keyv.compress('whatever');
+	const decompressed = await keyv.decompress(compressed);
+	t.is(decompressed, 'whatever');
+});
+
+test('decompression using number array with v8', async t => {
+	const options = {
+		serialize: v8.serialize,
+		deserialize: v8.deserialize,
+	};
+
+	const keyv = new KeyvBrotli(options);
+	const compressed = await keyv.compress({help: [1, 2, 4]});
+	const decompressed = await keyv.decompress(compressed);
+	t.deepEqual(decompressed, {help: [1, 2, 4]});
+});
+
+test('decompression using number array with json-buffer', async t => {
+	const options = {
+		serialize: json.stringify,
+		deserialize: json.parse,
+	};
+
+	const keyv = new KeyvBrotli(options);
+	const compressed = await keyv.compress({help: [1, 2, 4]});
+	const decompressed = await keyv.decompress(compressed);
+	t.deepEqual(decompressed, {help: [1, 2, 4]});
+});
+
+test('deserialize with an empty value', async t => {
+	const keyv = new KeyvBrotli();
+	// @ts-expect-error - Testing empty value
+	const deserialized = await keyv.deserialize('');
+
+	// @ts-expect-error - empty value
+	t.is(deserialized, '');
+});