@tsed/redis 8.29.0

package/lib/esm/domain/RedisConfiguration.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/domain/RedisStore.js

@@ -0,0 +1,95 @@
+import { createClient, createCluster } from "redis";
+const getVal = (value) => JSON.stringify(value) || '"undefined"';
+export class RedisStore {
+    constructor(options) {
+        this.name = "redis";
+        options = options || {};
+        this.redisCache =
+            options.redisInstance ||
+                ("clusterConfig" in options
+                    ? createCluster({ rootNodes: options.clusterConfig.nodes, ...(options.clusterConfig.options || {}) })
+                    : createClient(options));
+        this.redisCache.connect?.().catch(() => undefined);
+        this.storeArgs = options;
+        this.isCacheable = this.isCacheableValue =
+            this.storeArgs.isCacheable || this.storeArgs.isCacheableValue || ((value) => value !== undefined && value !== null);
+    }
+    get client() {
+        return this.redisCache;
+    }
+    getClient() {
+        return this.redisCache;
+    }
+    async set(key, value, ttl) {
+        this.assertCacheable(value);
+        ttl = this.getTtl(ttl);
+        const val = getVal(value);
+        if (ttl) {
+            if (this.redisCache.setEx) {
+                await this.redisCache.setEx(key, ttl, val);
+            }
+            else {
+                await this.redisCache.set(key, val, { EX: ttl });
+            }
+            return;
+        }
+        await this.redisCache.set(key, val);
+    }
+    async get(key, options) {
+        const val = await this.redisCache.get(key);
+        if (val === undefined || val === null) {
+            return undefined;
+        }
+        return JSON.parse(val);
+    }
+    async del(key) {
+        await this.redisCache.del(key);
+    }
+    async mset(args, ttl) {
+        ttl = this.getTtl(ttl);
+        if (ttl) {
+            const multi = this.redisCache.multi();
+            for (const [key, value] of args) {
+                this.assertCacheable(value);
+                if (multi.setEx) {
+                    multi.setEx(key, ttl / 1000, getVal(value));
+                }
+                else {
+                    multi.set(key, getVal(value), { EX: ttl / 1000 });
+                }
+            }
+            await multi.exec();
+        }
+        else
+            await this.redisCache.mSet(args.reduce((acc, [key, value]) => {
+                this.assertCacheable(value);
+                acc[key] = getVal(value);
+                return acc;
+            }, {}));
+    }
+    async mget(...args) {
+        const x = await this.redisCache.mGet(args);
+        return x.map((x) => (x === null || x === undefined ? undefined : JSON.parse(x)));
+    }
+    async mdel(...args) {
+        await this.redisCache.del(...args);
+    }
+    async reset() {
+        await this.redisCache.flushAll();
+    }
+    keys(pattern = "*") {
+        return this.redisCache.keys(pattern);
+    }
+    ttl(key) {
+        return this.redisCache.ttl(key);
+    }
+    getTtl(ttl) {
+        return ttl === undefined ? this.storeArgs.ttl : ttl;
+    }
+    assertCacheable(value) {
+        if (!this.isCacheable(value)) {
+            throw new Error(`"${getVal(value)}" is not a cacheable value`);
+        }
+    }
+}
+export const redisStore = (config) => new RedisStore(config);

package/lib/esm/domain/index.js

@@ -0,0 +1,2 @@
+export * from "./RedisConfiguration.js";
+export * from "./RedisStore.js";

package/lib/esm/index.js

@@ -0,0 +1,8 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./domain/index.js";
+export * from "./domain/RedisConfiguration.js";
+export * from "./domain/RedisStore.js";
+export * from "./utils/createConnection.js";
+export * from "./utils/registerConnectionProvider.js";

package/lib/esm/utils/createConnection.js

@@ -0,0 +1,43 @@
+import { configuration, logger } from "@tsed/di";
+import { createClient, createCluster } from "redis";
+import { redisStore } from "../domain/RedisStore.js";
+export async function createConnection(config) {
+    const { name, cache, ...redisOptions } = config;
+    const retryStrategy = (times) => {
+        logger().fatal({ event: "REDIS_ERROR", message: `Redis is not responding - Retry count: ${times}` });
+        return 2000;
+    };
+    let connection;
+    const reconnectOnError = (err) => {
+        logger().fatal({
+            event: "REDIS_ERROR",
+            message: `Redis - Reconnect on error: ${(err && err.message) || err}`,
+            stack: err?.stack
+        });
+    };
+    if ("nodes" in redisOptions) {
+        const { nodes, ...clusterOptions } = redisOptions;
+        connection = createCluster({
+            rootNodes: nodes,
+            ...clusterOptions
+        });
+    }
+    else {
+        connection = createClient({
+            ...redisOptions,
+            socket: {
+                reconnectStrategy: retryStrategy,
+                ...redisOptions.socket
+            }
+        });
+        connection.on?.("error", reconnectOnError);
+    }
+    await connection.connect();
+    logger().info("Connected to redis database...");
+    if (configuration().get("cache") && cache) {
+        configuration().set("cache.redisInstance", connection);
+        configuration().set("cache.store", redisStore);
+    }
+    connection.name = name;
+    return connection;
+}

package/lib/esm/utils/registerConnectionProvider.js

@@ -0,0 +1,20 @@
+import { constant, injectable } from "@tsed/di";
+import { createConnection } from "./createConnection.js";
+export const REDIS_CONNECTIONS = Symbol.for("redis:connections");
+export function registerConnectionProvider({ token, name = "default" }) {
+    return injectable(token, {
+        connectionName: name
+    })
+        .type(REDIS_CONNECTIONS)
+        .asyncFactory(async () => {
+        const items = constant("redis", []);
+        const item = items.find((item) => item.name === name);
+        return item
+            ? createConnection({ ...item, name }).then((connection) => {
+                connection.name = name;
+                return connection;
+            })
+            : { name };
+    })
+        .token();
+}

package/lib/types/domain/RedisConfiguration.d.ts

@@ -0,0 +1,20 @@
+import { TokenProvider } from "@tsed/di";
+import type { RedisClientOptions, RedisClientType, RedisClusterType } from "redis";
+export type ClusterConfiguration = {
+    nodes: any[];
+} & Record<string, any>;
+export interface BaseRedisConfiguration {
+    name?: TokenProvider;
+    cache?: boolean;
+}
+export type RedisConfiguration = BaseRedisConfiguration & (RedisClientOptions | ClusterConfiguration) & {
+    redisInstance?: RedisClientType | RedisClusterType<any, any>;
+    sentinelName?: string;
+};
+declare global {
+    namespace TsED {
+        interface Configuration {
+            redis?: RedisConfiguration[];
+        }
+    }
+}

package/lib/types/domain/RedisStore.d.ts

@@ -0,0 +1,37 @@
+import type { RedisClusterOptions } from "@redis/client";
+import type { Config, FactoryConfig, Store } from "cache-manager";
+import type { RedisClientType, RedisClusterType } from "redis";
+export interface RedisClusterConfig {
+    nodes: RedisClusterOptions["rootNodes"][];
+    options?: Record<string, any>;
+}
+export type RedisStoreCtrOptions = (Record<string, any> | {
+    clusterConfig: RedisClusterConfig;
+}) & Config & {
+    redisInstance?: RedisClientType | RedisClusterType<any, any>;
+};
+export declare class RedisStore implements Store {
+    name: string;
+    /**
+     * @deprecated
+     */
+    isCacheableValue: any;
+    isCacheable: any;
+    private redisCache;
+    private storeArgs;
+    constructor(options?: RedisStoreCtrOptions);
+    get client(): RedisClientType | RedisClusterType<any, any>;
+    getClient(): RedisClientType | RedisClusterType<any, any>;
+    set(key: string, value: any, ttl?: number): Promise<void>;
+    get<T = any>(key: string, options?: any): Promise<T | undefined>;
+    del(key: string): Promise<void>;
+    mset(args: [string, unknown][], ttl?: number): Promise<void>;
+    mget(...args: string[]): Promise<any>;
+    mdel(...args: string[]): Promise<void>;
+    reset(): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+    ttl(key: string): Promise<number>;
+    private getTtl;
+    private assertCacheable;
+}
+export declare const redisStore: (config?: FactoryConfig<any>) => RedisStore;

package/lib/types/domain/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./RedisConfiguration.js";
+export * from "./RedisStore.js";

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./domain/index.js";
+export * from "./domain/RedisConfiguration.js";
+export * from "./domain/RedisStore.js";
+export * from "./utils/createConnection.js";
+export * from "./utils/registerConnectionProvider.js";

package/lib/types/utils/createConnection.d.ts

@@ -0,0 +1,3 @@
+import { type RedisClientType, type RedisClusterType } from "redis";
+import { RedisConfiguration } from "../domain/RedisConfiguration.js";
+export declare function createConnection(config: RedisConfiguration): Promise<RedisClientType | RedisClusterType<any, any>>;

package/lib/types/utils/registerConnectionProvider.d.ts

@@ -0,0 +1,15 @@
+import { type FactoryTokenProvider, TokenProvider } from "@tsed/di";
+import type { RedisClientType, RedisClusterType } from "redis";
+export interface CreateConnectionProviderProps {
+    token: TokenProvider;
+    /**
+     * @deprecated use `token` instead of `provide`
+     */
+    provide?: TokenProvider;
+    name?: string;
+}
+export declare const REDIS_CONNECTIONS: unique symbol;
+export type RedisConnection = (RedisClientType | RedisClusterType<any, any>) & {
+    name: string;
+};
+export declare function registerConnectionProvider({ token, name }: CreateConnectionProviderProps): FactoryTokenProvider<RedisConnection>;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@tsed/redis",
+  "description": "Redis (node-redis) connection for Ts.ED",
+  "type": "module",
+  "version": "8.29.0",
+  "source": "./src/index.ts",
+  "main": "./lib/esm/index.js",
+  "module": "./lib/esm/index.js",
+  "typings": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "tsed-source": "./src/index.ts",
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "default": "./lib/esm/index.js"
+    },
+    "./cache": {
+      "tsed-source": "./src/domain/index.ts",
+      "types": "./lib/types/domain/index.d.ts",
+      "import": "./lib/esm/domain/index.js",
+      "default": "./lib/esm/domain/index.js"
+    }
+  },
+  "scripts": {
+    "build": "yarn barrels && yarn build:ts",
+    "barrels": "barrels",
+    "test": "vitest run",
+    "build:ts": "tsc --build tsconfig.esm.json",
+    "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
+  },
+  "dependencies": {
+    "tslib": ">=2.7.0"
+  },
+  "devDependencies": {
+    "@tsed/barrels": "8.29.0",
+    "@tsed/core": "8.29.0",
+    "@tsed/di": "8.29.0",
+    "@tsed/typescript": "8.29.0",
+    "eslint": "9.12.0",
+    "redis": "6.0.0",
+    "typescript": "6.0.2",
+    "vitest": "4.1.4"
+  },
+  "peerDependencies": {
+    "@tsed/core": ">=8.0.0",
+    "@tsed/di": ">=8.0.0",
+    "redis": ">=5.1.0"
+  },
+  "repository": "https://github.com/tsedio/tsed",
+  "bugs": {
+    "url": "https://github.com/tsedio/tsed/issues"
+  },
+  "homepage": "https://github.com/tsedio/tsed/tree/production/packages/orm/redis",
+  "author": "Romain Lenzotti",
+  "license": "MIT"
+}

package/readme.md

@@ -0,0 +1,285 @@
+<p style="text-align: center" align="center">
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+</p>
+
+<div align="center">
+   <h1>@tsed/redis</h1>
+
+[![Build & Release](https://github.com/tsedio/tsed/workflows/Build%20&%20Release/badge.svg)](https://github.com/tsedio/tsed/actions?query=workflow%3A%22Build+%26+Release%22)
+[![PR Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/tsedio/tsed/blob/master/CONTRIBUTING.md)
+[![npm version](https://badge.fury.io/js/%40tsed%2Fcommon.svg)](https://badge.fury.io/js/%40tsed%2Fcommon)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![github](https://img.shields.io/static/v1?label=Github%20sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86)](https://github.com/sponsors/romakita)
+[![opencollective](https://img.shields.io/static/v1?label=OpenCollective%20sponsor&message=%E2%9D%A4&logo=OpenCollective&color=%23fe8e86)](https://opencollective.com/tsed)
+
+</div>
+
+<div align="center">
+  <a href="https://tsed.dev/">Website</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://tsed.dev/getting-started/">Getting started</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://slack.tsed.dev">Slack</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/TsED_io">Twitter</a>
+</div>
+
+<hr />
+
+A package of Ts.ED framework. See website: https://tsed.dev/tutorials/redis.html
+
+## Features
+
+Currently, `@tsed/redis` allows you:
+
+- Configure one or more Redis database connections via the `@Configuration` configuration.
+- Share redis connection with `@tsed/platform-cache`.
+- Support classic Redis connection and Cluster connection.
+- Inject connection to another service.
+- Mock connection for unit/integration test.
+
+## Installation
+
+```shell
+npm install --save @tsed/redis redis redis-mock
+```
+
+> Minimal supported redis version is v5+
+
+## Create connection
+
+Create a new `RedisConnection.ts` file in your project:
+
+```typescript
+import type {RedisClientType} from "redis";
+import {registerConnectionProvider} from "@tsed/redis";
+
+export const REDIS_CONNECTION = Symbol.for("REDIS_CONNECTION");
+export type REDIS_CONNECTION = RedisClientType;
+
+registerConnectionProvider({
+  token: REDIS_CONNECTION,
+  name: "default"
+});
+```
+
+> registerConnectionProvider create automatically an injectable RedisConnection
+
+Then, edit your `Server.ts`:
+
+```typescript
+import {Configuration} from "@tsed/di";
+import "@tsed/platform-cache"; // add this module if you want to use cache
+import "@tsed/redis";
+
+@Configuration({
+  redis: [
+    {
+      name: "default",
+      // share the redis connection with @tsed/platform-cache
+      cache: true
+
+      // redis options
+      // host: "localhost",
+      // port: 6379,
+      // username: "...",
+      // password: "...",
+      // tls: false,
+      // db: 0
+    }
+  ],
+  // cache options
+  cache: {
+    ttl: 300
+  }
+})
+class MyModule {}
+```
+
+And finally, use the connection in your services:
+
+```typescript
+import {Injectable} from "@tsed/di";
+
+@Injectable()
+export class ClientRepository {
+  @Inject(REDIS_CONNECTION)
+  protected connection: REDIS_CONNECTION; // redis instance
+
+  async keys() {
+    return this.connection.keys("clients:*");
+  }
+}
+```
+
+> See [redis documentation](https://github.com/redis/node-redis) for more details.
+
+## Cluster configuration
+
+```typescript
+import {Configuration} from "@tsed/di";
+import "@tsed/platform-cache"; // add this module if you want to use cache
+import "@tsed/redis";
+
+@Configuration({
+  redis: [
+    {
+      name: "default",
+      // share the redis connection with @tsed/platform-cache
+      cache: true,
+      // cluster options
+      nodes: ["..."],
+      // other cluster options
+      scaleReads: "all",
+      maxRedirections: 16,
+      retryDelayOnTryAgain: 100,
+      retryDelayOnFailover: 200,
+      retryDelayOnClusterDown: 1000,
+      slotsRefreshTimeout: 15000,
+      slotsRefreshInterval: 20000,
+      enableOfflineQueue: true,
+      enableReadyCheck: true,
+      redisOptions: {
+        noDelay: true,
+        connectTimeout: 15000,
+        autoResendUnfulfilledCommands: true,
+        maxRetriesPerRequest: 5,
+        enableAutoPipelining: true,
+        autoPipeliningIgnoredCommands: ["scan"]
+      }
+      //
+    }
+  ],
+  // cache options
+  cache: {
+    ttl: 300
+  }
+})
+class MyModule {}
+```
+
+## Testing
+
+Ts.ED provides a utility that allows you to test a service that consumes a Redis connection.
+This use relies on the awesome [redis-mock](https://www.npmjs.com/package/redis-mock) module.
+
+Here is a class that consume a redis connection:
+
+```typescript
+import {v4} from "uuid";
+import {Injectable} from "@tsed/di";
+import {serialize, deserialize} from "@tsed/json-mapper";
+import {REDIS_CONNECTION} from "./RedisConnection.js";
+import {ClientModel} from "./ClientModel.js";
+
+@Injectable()
+export class ClientRepository {
+  @Inject(REDIS_CONNECTION)
+  protected connection: REDIS_CONNECTION; // redis instance
+
+  async get(id: string) {
+    const raw = await this.connection.get("clients:" + id);
+
+    if (!raw) {
+      return undefined;
+    }
+
+    return deserialize(JSON.parse(raw), {type: ClientModel});
+  }
+
+  async save(client: ClientModel) {
+    client.id = client.id || v4();
+
+    this.connection.set("clients:" + client.id, JSON.stringify(serialize(client)));
+
+    return client;
+  }
+}
+```
+
+The ClientModel:
+
+```typescript
+import {Schema} from "@tsed/schema";
+
+export class ClientModel {
+  @Property()
+  id: string;
+
+  @Property()
+  name: string;
+}
+```
+
+And his test:
+
+```typescript
+import {ClientRepository} from "./ClientRepository.js";
+import {REDIS_CONNECTION} from "./RedisConnection.js";
+import {ClientModel} from "./ClientModel.js";
+
+describe("RedisTest", () => {
+  beforeEach(() => RedisTest.create()); // create a new sandbox with redis-mock connection
+  afterEach(() => RedisTest.reset());
+
+  it("should return nothing", async () => {
+    const service = RedisTest.get<MyRepository>(MyRepository);
+
+    const client = await service.get("uid");
+
+    expect(client).toEqual(undefined);
+  });
+
+  it("should return all keys", async () => {
+    const service = RedisTest.get<MyRepository>(MyRepository);
+    const client = new ClientModel();
+    client.name = "name";
+
+    const newClient = await service.save(client);
+
+    expect(newClient.id).toBeInstanceOf(String);
+    expect(newClient.name).toEqual("name");
+
+    const clientFound = await service.get(newClient.id);
+
+    expect(clientFound).toBeInstanceOf(ClientModel);
+    expect(clientFound.id).toEqual(newClient.id);
+    expect(clientFound.name).toEqual("name");
+  });
+});
+```
+
+## Contributors
+
+<a href="https://github.com/tsedio/ts-express-decorators/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/tsed#backer)]
+
+<a href="https://opencollective.com/tsed#backers" target="_blank"><img src="https://opencollective.com/tsed/backers.svg?width=890"></a>
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your
+website. [[Become a sponsor](https://opencollective.com/tsed#sponsor)]
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2016 - 2022 Romain Lenzotti
+
+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.