@tsed/adapters-redis 8.28.8 → 8.29.0

package/lib/esm/adapters/OIDCRedisAdapter.js

@@ -1,22 +1,20 @@
 import { __decorate, __metadata, __param } from "tslib";
-import { Configuration, Inject, Opts } from "@tsed/di";
-import { IOREDIS_CONNECTIONS } from "@tsed/ioredis";
+import { Opts } from "@tsed/di";
 import { RedisAdapter } from "./RedisAdapter.js";
 const GRANTABLE = new Set(["AccessToken", "AuthorizationCode", "RefreshToken", "DeviceCode", "BackchannelAuthenticationRequest"]);
 const CONSUMABLE = new Set(["AuthorizationCode", "RefreshToken", "DeviceCode", "BackchannelAuthenticationRequest"]);
-function grantKeyFor(id) {
-    return `$oidc:grant:${id}`;
-}
-function userCodeKeyFor(userCode) {
-    return `$oidc:userCode:${userCode}`;
-}
-function uidKeyFor(uid) {
-    return `$oidc:uid:${uid}`;
-}
 let OIDCRedisAdapter = class OIDCRedisAdapter extends RedisAdapter {
-    constructor(options, connections, configuration) {
-        super(options, connections, configuration);
-        this.configuration = configuration;
+    grantKeyFor(id) {
+        return this.prefix(`$oidc:grant:${id}`);
+    }
+    userCodeKeyFor(userCode) {
+        return this.prefix(`$oidc:userCode:${userCode}`);
+    }
+    uidKeyFor(uid) {
+        return this.prefix(`$oidc:uid:${uid}`);
+    }
+    constructor(options) {
+        super(options);
         this.useHash = CONSUMABLE.has(this.collectionName);
         this.isGrantable = GRANTABLE.has(this.collectionName);
         this.hooks.on("insert", this.onInsert.bind(this));
@@ -25,55 +23,53 @@ let OIDCRedisAdapter = class OIDCRedisAdapter extends RedisAdapter {
         const id = payload._id;
         const key = this.key(id);
         if (this.isGrantable && payload.grantId) {
-            const grantKey = grantKeyFor(payload.grantId);
-            multi.rpush(grantKey, key);
+            const grantKey = this.grantKeyFor(payload.grantId);
+            this.callCmd(multi, ["rPush", "rpush"], grantKey, key);
             // if you're seeing grant key lists growing out of acceptable proportions consider using LTRIM
             // here to trim the list to an appropriate length
-            const ttl = await this.db.ttl(grantKey);
+            const ttl = await this.callCmd(this.db, ["ttl"], grantKey);
             if (expiresIn && expiresIn > ttl) {
-                multi.expire(grantKey, expiresIn);
+                this.callCmd(multi, ["expire"], grantKey, expiresIn);
             }
         }
         if (payload.userCode) {
-            const userCodeKey = userCodeKeyFor(payload.userCode);
-            multi.set(userCodeKey, id);
-            expiresIn && multi.expire(userCodeKey, expiresIn);
+            const userCodeKey = this.userCodeKeyFor(payload.userCode);
+            this.callCmd(multi, ["set"], userCodeKey, id);
+            expiresIn && this.callCmd(multi, ["expire"], userCodeKey, expiresIn);
         }
         if (payload.uid) {
-            const uidKey = uidKeyFor(payload.uid);
-            multi.set(uidKey, id);
-            expiresIn && multi.expire(uidKey, expiresIn);
+            const uidKey = this.uidKeyFor(payload.uid);
+            this.callCmd(multi, ["set"], uidKey, id);
+            expiresIn && this.callCmd(multi, ["expire"], uidKey, expiresIn);
         }
         return multi;
     }
     async findByUid(uid) {
-        const id = await this.db.get(uidKeyFor(uid));
+        const id = await this.callCmd(this.db, ["get"], this.uidKeyFor(uid));
         return id && this.findById(id);
     }
     async findByUserCode(userCode) {
-        const id = await this.db.get(userCodeKeyFor(userCode));
+        const id = await this.callCmd(this.db, ["get"], this.userCodeKeyFor(userCode));
         return id && this.findById(id);
     }
     async destroy(id) {
         const key = this.key(id);
-        await this.db.del(key);
+        await this.callCmd(this.db, ["del"], key);
     }
     async revokeByGrantId(grantId) {
         const multi = this.db.multi();
-        const key = grantKeyFor(grantId);
-        const tokens = await this.db.lrange(key, 0, -1);
-        tokens.forEach((token) => multi.del(token));
-        multi.del(grantKeyFor(grantId));
-        await multi.exec();
+        const key = this.grantKeyFor(grantId);
+        const tokens = await this.callCmd(this.db, ["lRange", "lrange"], key, 0, -1);
+        tokens.forEach((token) => this.callCmd(multi, ["del"], token));
+        this.callCmd(multi, ["del"], this.grantKeyFor(grantId));
+        await this.callCmd(multi, ["exec"]);
     }
     async consume(id) {
-        await this.db.hset(this.key(id), "consumed", Math.floor(Date.now() / 1000));
+        await this.callCmd(this.db, ["hSet", "hset"], this.key(id), "consumed", Math.floor(Date.now() / 1000));
     }
 };
 OIDCRedisAdapter = __decorate([
     __param(0, Opts),
-    __param(1, Inject(IOREDIS_CONNECTIONS)),
-    __param(2, Configuration()),
-    __metadata("design:paramtypes", [Object, Array, Object])
+    __metadata("design:paramtypes", [Object])
 ], OIDCRedisAdapter);
 export { OIDCRedisAdapter };

package/lib/esm/adapters/RedisAdapter.js

@@ -1,29 +1,27 @@
 import { __decorate, __metadata, __param } from "tslib";
 import { Adapter } from "@tsed/adapters";
 import { cleanObject, isObject, isString } from "@tsed/core";
-import { Configuration, Inject, Opts } from "@tsed/di";
+import { injectMany, Opts } from "@tsed/di";
 import { Hooks } from "@tsed/hooks";
-import { IOREDIS_CONNECTIONS } from "@tsed/ioredis";
+import { REDIS_CONNECTIONS } from "@tsed/redis";
 import { v4 as uuid } from "uuid";
-const getId = (key) => key.split(":")[2];
-const flatKeys = (keys) => {
-    return keys.flatMap(([, result]) => result).filter(Boolean);
-};
 let RedisAdapter = class RedisAdapter extends Adapter {
-    constructor(options, connections, configuration) {
-        super(options, configuration);
-        this.configuration = configuration;
+    constructor(options) {
+        super(options);
         this.hooks = new Hooks();
         this.useHash = false;
         this.useHash = Boolean(options.useHash);
         this.connectionName = options.connectionName || "default";
-        this.connection = connections.find((connection) => connection.name === this.connectionName); // || connections[0];
+        this.keyPrefix = options.keyPrefix || "";
+        this.connection = injectMany(REDIS_CONNECTIONS).find((connection) => {
+            return connection.name === this.connectionName;
+        }); // || connections[0];
     }
     get db() {
         return this.connection;
     }
     key(id) {
-        return `${this.collectionName}:${id}`;
+        return this.prefix(`${this.collectionName}:${id}`);
     }
     create(payload, expiresAt) {
         delete payload._id;
@@ -60,14 +58,16 @@ let RedisAdapter = class RedisAdapter extends Adapter {
         if (foundKeys.length < keys.length) {
             return undefined;
         }
-        const getId = (key) => key.split(":")[2];
-        const id = getId(foundKeys[0]);
-        foundKeys = foundKeys.filter((key) => id === getId(key));
+        const id = this.extractIdFromIndexedKey(foundKeys[0]);
+        if (!id) {
+            return undefined;
+        }
+        foundKeys = foundKeys.filter((key) => id === this.extractIdFromIndexedKey(key));
         return keys.length === foundKeys.length ? this.findById(id) : undefined;
     }
     async findById(_id) {
         const key = this.key(_id);
-        const item = this.useHash ? await this.db.hgetall(key) : await this.db.get(key);
+        const item = this.useHash ? await this.callCmd(this.db, ["hGetAll", "hgetall"], key) : await this.callCmd(this.db, ["get"], key);
         // hgetall returns an empty object when there are no results, so we need to check for that.
         if (!item || (this.useHash && isObject(item) && Object.keys(item).length === 0)) {
             return undefined;
@@ -98,7 +98,7 @@ let RedisAdapter = class RedisAdapter extends Adapter {
         if (item) {
             const id = this.key(item._id);
             const indexIds = await this.getAllIndex(item._id);
-            await this.db.del([id, ...indexIds]);
+            await this.callCmd(this.db, ["del"], id, ...indexIds);
             return this.deserialize(item);
         }
     }
@@ -107,29 +107,43 @@ let RedisAdapter = class RedisAdapter extends Adapter {
     }
     async deleteMany(predicate) {
         const items = await this.findAll(predicate);
-        const pipeline = this.db.pipeline();
         const ids = [];
         const results = items.map((item) => {
             ids.push(this.key(item._id));
-            this.getAllIndex(item._id, pipeline);
             return this.deserialize(item);
         });
-        const keys = await pipeline.exec();
-        this.db.del([...ids, ...flatKeys(keys)]);
+        const indexesByItem = await Promise.all(items.map((item) => this.getAllIndex(item._id)));
+        const indexKeys = indexesByItem.flat();
+        if (ids.length || indexKeys.length) {
+            await this.callCmd(this.db, ["del"], ...ids, ...indexKeys);
+        }
         return results;
     }
+    prefix(key) {
+        return this.keyPrefix ? `${this.keyPrefix}:${key}` : key;
+    }
+    callCmd(target, methods, ...args) {
+        const method = methods.map((name) => target?.[name]).find((fn) => typeof fn === "function");
+        if (!method) {
+            throw new Error(`Redis command not available: ${methods.join(" or ")}`);
+        }
+        return method.call(target, ...args);
+    }
+    extractIdFromIndexedKey(key) {
+        const parts = key.split(":");
+        const collectionIndex = parts.lastIndexOf(this.collectionName);
+        return collectionIndex > -1 ? parts[collectionIndex + 1] : undefined;
+    }
     async findKeys(props) {
         const keys = Object.keys(props);
-        const pipeline = this.db.pipeline();
-        this.indexes
+        const patterns = this.indexes
             .filter(({ propertyKey }) => keys.includes(propertyKey))
-            .forEach(({ propertyKey }) => {
-            const value = props[propertyKey];
-            const patterns = this.getIndexedKey("*", propertyKey, value);
-            pipeline.keys(patterns);
-        });
-        const results = await pipeline.exec();
-        return flatKeys(results);
+            .map(({ propertyKey }) => this.getIndexedKey("*", propertyKey, props[propertyKey]));
+        if (!patterns.length) {
+            return [];
+        }
+        const results = await Promise.all(patterns.map((pattern) => this.callCmd(this.db, ["keys"], pattern)));
+        return results.flat().filter(Boolean).sort();
     }
     async insert(payload, expiresAt) {
         const id = (payload._id = payload._id || uuid());
@@ -138,41 +152,40 @@ let RedisAdapter = class RedisAdapter extends Adapter {
         const multi = this.db.multi();
         const key = this.key(id);
         const strPayload = JSON.stringify(this.serialize(payload));
-        this.useHash ? await multi.hset(key, { payload: strPayload }) : await multi.set(key, strPayload);
+        if (this.useHash) {
+            this.callCmd(multi, ["hSet", "hset"], key, { payload: strPayload });
+        }
+        else {
+            this.callCmd(multi, ["set"], key, strPayload);
+        }
         if (expiresIn) {
-            multi.expire(key, expiresIn);
+            this.callCmd(multi, ["expire"], key, expiresIn);
         }
         this.indexes.forEach(({ propertyKey }) => {
             const value = payload[propertyKey];
             const indexedKey = this.getIndexedKey(id, propertyKey, value);
-            multi.set(indexedKey, id);
-            expiresIn && multi.expire(indexedKey, expiresIn);
+            this.callCmd(multi, ["set"], indexedKey, id);
+            expiresIn && this.callCmd(multi, ["expire"], indexedKey, expiresIn);
         });
         await this.hooks.asyncAlter("insert", multi, [payload, expiresIn]);
-        await multi.exec();
+        await this.callCmd(multi, ["exec"]);
         const result = this.deserialize(payload, { useAlias: false });
         await this.hooks.asyncEmit("afterInsert", [result]);
         return result;
     }
-    getAllIndex(id, pipeline) {
-        const key = ["$idx", this.key(id), "*"].join(":");
-        return (pipeline || this.db).keys(key);
+    getAllIndex(id) {
+        const key = this.prefix(["$idx", `${this.collectionName}:${id}`, "*"].join(":"));
+        return this.callCmd(this.db, ["keys"], key);
     }
     getIndexedKey(id, propertyKey, value) {
-        const key = this.key(id);
-        return ["$idx", key, `${propertyKey}(${value})`].map(String).join(":");
+        const key = `${this.collectionName}:${id}`;
+        return this.prefix(["$idx", key, `${propertyKey}(${value})`].map(String).join(":"));
     }
     async getAll() {
-        const keys = await this.db.keys(`${this.collectionName}:*`);
-        const pipeline = this.db.pipeline();
-        keys.forEach((key) => {
-            pipeline.get(key);
-        });
-        const result = await pipeline.exec();
+        const keys = (await this.callCmd(this.db, ["keys"], this.prefix(`${this.collectionName}:*`))).sort();
+        const result = await Promise.all(keys.map((key) => this.callCmd(this.db, ["get"], key)));
         return (result || [])
-            .map(([, data]) => {
-            return typeof data === "string" ? this.deserialize(JSON.parse(data)) : undefined;
-        })
+            .map((data) => (typeof data === "string" ? this.deserialize(JSON.parse(data)) : undefined))
             .filter(Boolean);
     }
     async findAllBy(props) {
@@ -182,7 +195,10 @@ let RedisAdapter = class RedisAdapter extends Adapter {
             return [];
         }
         const map = foundKeys.reduce((map, key) => {
-            const id = getId(key);
+            const id = this.extractIdFromIndexedKey(key);
+            if (!id) {
+                return map;
+            }
             const value = map.get(id) || 0;
             return map.set(id, value + 1);
         }, new Map());
@@ -193,8 +209,6 @@ let RedisAdapter = class RedisAdapter extends Adapter {
 };
 RedisAdapter = __decorate([
     __param(0, Opts),
-    __param(1, Inject(IOREDIS_CONNECTIONS)),
-    __param(2, Configuration()),
-    __metadata("design:paramtypes", [Object, Array, Object])
+    __metadata("design:paramtypes", [Object])
 ], RedisAdapter);
 export { RedisAdapter };

package/lib/types/adapters/OIDCRedisAdapter.d.ts

@@ -1,16 +1,17 @@
 import { AdapterModel } from "@tsed/adapters";
-import { Configuration } from "@tsed/di";
-import { IORedis } from "@tsed/ioredis";
-import { ChainableCommander } from "ioredis";
 import { RedisAdapter, RedisAdapterConstructorOptions } from "./RedisAdapter.js";
+type ChainableCommander = any;
 export declare class OIDCRedisAdapter<T extends AdapterModel> extends RedisAdapter<T> {
-    protected configuration: Configuration;
     protected isGrantable: boolean;
-    constructor(options: RedisAdapterConstructorOptions, connections: IORedis[], configuration: Configuration);
-    onInsert(multi: ChainableCommander, payload: T, expiresIn: number): Promise<ChainableCommander>;
-    findByUid(uid: string): Promise<"" | T | null | undefined>;
-    findByUserCode(userCode: string): Promise<"" | T | null | undefined>;
+    protected grantKeyFor(id: string): string;
+    protected userCodeKeyFor(userCode: string): string;
+    protected uidKeyFor(uid: string): string;
+    constructor(options: RedisAdapterConstructorOptions);
+    onInsert(multi: ChainableCommander, payload: T, expiresIn: number): Promise<any>;
+    findByUid(uid: string): Promise<any>;
+    findByUserCode(userCode: string): Promise<any>;
     destroy(id: string): Promise<void>;
     revokeByGrantId(grantId: string): Promise<void>;
     consume(id: string): Promise<void>;
 }
+export {};

package/lib/types/adapters/RedisAdapter.d.ts

@@ -1,19 +1,19 @@
 import { Adapter, AdapterConstructorOptions, AdapterModel } from "@tsed/adapters";
-import { Configuration } from "@tsed/di";
 import { Hooks } from "@tsed/hooks";
-import { IORedis } from "@tsed/ioredis";
-import type { ChainableCommander, Redis } from "ioredis";
+import { RedisConnection } from "@tsed/redis";
+type Redis = any;
 export interface RedisAdapterConstructorOptions extends AdapterConstructorOptions {
     connectionName?: string;
+    keyPrefix?: string;
     useHash?: boolean;
 }
 export declare class RedisAdapter<Model extends AdapterModel> extends Adapter<Model> {
-    protected configuration: Configuration;
     readonly hooks: Hooks;
     readonly connectionName: string;
-    readonly connection: IORedis;
+    readonly connection: RedisConnection;
+    readonly keyPrefix: string;
     protected useHash: boolean;
-    constructor(options: RedisAdapterConstructorOptions, connections: IORedis[], configuration: Configuration);
+    constructor(options: RedisAdapterConstructorOptions);
     get db(): Redis;
     key(id: string): string;
     create(payload: Partial<Model>, expiresAt?: Date): Promise<Model>;
@@ -26,11 +26,14 @@ export declare class RedisAdapter<Model extends AdapterModel> extends Adapter<Mo
     deleteOne(predicate: Partial<Model & any>): Promise<Model | undefined>;
     deleteById(_id: string): Promise<Model | undefined>;
     deleteMany(predicate: Partial<Model>): Promise<Model[]>;
+    prefix(key: string): string;
+    protected callCmd(target: any, methods: string[], ...args: any[]): any;
+    protected extractIdFromIndexedKey(key: string): string | undefined;
     protected findKeys(props: any): Promise<string[]>;
     protected insert(payload: Partial<Model>, expiresAt?: Date): Promise<any>;
     protected getAllIndex(id: string): Promise<string[]>;
-    protected getAllIndex(id: string, pipeline: ChainableCommander): ChainableCommander;
     protected getIndexedKey(id: string, propertyKey: string, value: any): string;
     protected getAll(): Promise<Model[]>;
     protected findAllBy(props: Partial<Model & any>): Promise<Model[]>;
 }
+export {};

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

@@ -1,9 +1,9 @@
 import { AdaptersSettings } from "@tsed/adapters";
-import { RedisOptions } from "ioredis";
+import { RedisClientOptions } from "redis";
 declare global {
     namespace TsED {
         interface AdaptersOptions extends AdaptersSettings {
-            redis: RedisOptions & {
+            redis: RedisClientOptions & {
                 indexes?: {
                     [propertyKey: string]: Record<string, any>;
                 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/adapters-redis",
   "description": "Redis adapter for Ts.ED",
   "type": "module",
-  "version": "8.28.8",
+  "version": "8.29.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -23,16 +23,19 @@
     "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
-    "@tsed/adapters": "8.28.8",
-    "@tsed/ioredis": "8.28.8",
+    "@tsed/adapters": "8.29.0",
+    "@tsed/redis": "8.29.0",
     "tslib": ">=2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.28.8",
-    "@tsed/core": "8.28.8",
-    "@tsed/hooks": "8.28.8",
-    "@tsed/typescript": "8.28.8",
+    "@testcontainers/redis": "^11.7.2",
+    "@tsed/barrels": "8.29.0",
+    "@tsed/core": "8.29.0",
+    "@tsed/di": "8.29.0",
+    "@tsed/hooks": "8.29.0",
+    "@tsed/typescript": "8.29.0",
     "eslint": "9.12.0",
+    "testcontainers": "11.7.2",
     "typescript": "6.0.2",
     "vitest": "4.1.4"
   },
@@ -42,8 +45,7 @@
     "@tsed/di": ">=8.0.0",
     "@tsed/hooks": ">=8.0.0",
     "@tsed/platform-http": ">=8.0.0",
-    "ioredis": ">=5.2.3",
-    "ioredis-mock": ">=8.2.2",
+    "redis": ">=5.1.0",
     "uuid": "^14.0.0"
   },
   "repository": "https://github.com/tsedio/tsed",

package/tests/setup/TestContainersRedis.ts

@@ -0,0 +1,69 @@
+import {RedisContainer, StartedRedisContainer} from "@testcontainers/redis";
+
+const KEY = "TEST_CONTAINER_REDIS";
+
+function getGlobal<T>(key: string): T | null {
+  // @ts-ignore
+  return global[key];
+}
+
+function setGlobal(key: string, environment: unknown) {
+  // @ts-ignore
+  global[key] = environment;
+}
+
+export class TestContainersRedis {
+  static createContainer(image = "redis:8.0.1") {
+    return new RedisContainer(image).start();
+  }
+
+  static async startContainer(image?: string) {
+    // await stopMockServer()
+    const container = getGlobal<StartedRedisContainer>(KEY) || (await this.createContainer(image));
+
+    setGlobal(KEY, container);
+
+    process.env.REDIS_URL = container.getConnectionUrl();
+
+    return {
+      container,
+      url: process.env.REDIS_URL
+    };
+  }
+
+  static async stopContainer() {
+    const container = getGlobal<StartedRedisContainer>(KEY);
+
+    process.stdout.write("Stopping redis database\n");
+
+    if (container) {
+      await this.reset();
+      await container.stop();
+    }
+  }
+
+  static async reset() {
+    const container = getGlobal<StartedRedisContainer>(KEY);
+    await container?.exec("redis-cli flushall");
+  }
+
+  static getUrl(): string {
+    return process.env.REDIS_URL as string;
+  }
+
+  static getRedisOptions() {
+    const url = new URL(this.getUrl());
+    return {
+      host: url.hostname,
+      password: url.password,
+      port: url.port ? Number(url.port) : 6379,
+      username: url.username,
+      tls:
+        url.protocol === "rediss:"
+          ? {
+              rejectUnauthorized: false
+            }
+          : undefined
+    };
+  }
+}

package/tests/setup/vi.setup.ts

@@ -0,0 +1,9 @@
+import {TestContainersRedis} from "./TestContainersRedis.js";
+
+export async function setup() {
+  await TestContainersRedis.startContainer();
+}
+
+export async function teardown() {
+  await TestContainersRedis.stopContainer();
+}